#include "actor.h"
#include "animationmanager.h"
#include <QtCore/QPropertyAnimation>
#include <QtCore/QVariantAnimation>
#include <QDebug>

static QVariant myBooleanInterpolator(const bool &start, const bool &end, qreal progress)
{
  return (progress == 1.0) ? end : start;
}

Actor::Actor(Color::Color color, bool local, QGraphicsItem *parent)
  : PixmapItem(parent), m_color(color), m_direction(Actor::None), m_local(local)
{
  m_pix  = ":/" + QString("actor%1").arg((m_color >> 1) + 1);
  // DON'T set any pixmap here. we've a pixmap in the animation
  //setPixmap(m_pix);
  // higher player "over" lower player
  setZValue(m_color * 10);

  /* setup icon for player */
  m_icon.setPixmap(m_pix);
  m_icon.setSprite(Constants::sprite_margin, Constants::sprite_margin, Constants::field_size.width, Constants::field_size.height);

  /* setup static images first
   * they are visible if no animation is running
   * and will be the first in m_images
   */
  for (int i = 0; i < 5; i++)
  {
    PixmapItem *img = new PixmapItem(m_pix, this);
    m_images.append(img);
    int x = i * Constants::sprite_offset + Constants::sprite_margin;
    int y = Actor::None * Constants::sprite_offset + Constants::sprite_margin;
    img->setSprite(x, y, Constants::field_size.width, Constants::field_size.height);
    img->setZValue(zValue());
    img->setVisible(false);
  }

  /* setup animation stuff */
  qRegisterAnimationInterpolator<bool>(myBooleanInterpolator);
  m_moving = new QParallelAnimationGroup(this);
  m_eating.append(NULL); // Actor::None
  m_eating.append(setupEatingAnimation(Actor::Left));
  m_eating.append(setupEatingAnimation(Actor::Right));
  m_eating.append(setupEatingAnimation(Actor::Up));
  m_eating.append(setupEatingAnimation(Actor::Down));

  /* make the picture showing the current direction visible */
  m_images[m_direction]->setVisible(true);
}

QSequentialAnimationGroup *Actor::setupEatingAnimation(Actor::Movement direction)
{
  QSequentialAnimationGroup *eating = new QSequentialAnimationGroup(this);
  eating->setLoopCount(-1);
  for (int i = 0; i < 4; i++)
  {
    PixmapItem *img = new PixmapItem(m_pix, this);
    m_images.append(img);
    int x = i * Constants::sprite_offset + Constants::sprite_margin;
    int y = direction * Constants::sprite_offset + Constants::sprite_margin;
    img->setSprite(x, y, Constants::field_size.width, Constants::field_size.height);
    img->setZValue(zValue());
    img->setVisible(false);

    QPropertyAnimation *fadein = new QPropertyAnimation(img, "visible", eating);
    fadein->setDuration(0);
    fadein->setEndValue(true);

    eating->addPause(100);

    QPropertyAnimation *fadeout = new QPropertyAnimation(img, "visible", eating);
    fadeout->setDuration(0);
    fadeout->setEndValue(false);

    QPropertyAnimation *move = new QPropertyAnimation(img, "pos", m_moving);
    move->setDuration(Constants::tick);
    move->setEndValue(QPoint(0, 0));
  }

  return eating;
}

Color::Color Actor::getColor()
{
  return m_color;
}

PixmapItem &Actor::getIcon()
{
  return m_icon;
}

bool Actor::isLocal()
{
  return m_local;
}

void Actor::move(Actor::Movement direction)
{
  //TODO: remove?
  if (isMoving())
    return;

  /* stop current animation */
  if (direction != m_direction)
  {
    /* hide all pictures */
    for (int i = 0; i < m_images.size(); ++i)
      m_images.at(i)->setVisible(false);

    if (m_eating[m_direction] != NULL)
    {
      m_eating[m_direction]->stop();
      //AnimationManager::self()->unregisterAnimation(m_eating[m_direction]);
    }
  }

  QPointF endpos(0, 0);
  switch(direction)
  {
  case Actor::None:
    break;
  case Actor::Left:
    endpos.setX(static_cast<qreal>(Constants::field_size.width) * -1);
    break;
  case Actor::Right:
    endpos.setX(Constants::field_size.width);
    break;
  case Actor::Up:
    endpos.setY(static_cast<qreal>(Constants::field_size.height) * -1);
    break;
  case Actor::Down:
    endpos.setY(Constants::field_size.height);
    break;
  default:
    Q_ASSERT(false);
    break;
  }

  for(int i = 0; i < m_moving->animationCount(); ++i)
  {
    QPropertyAnimation *move = dynamic_cast<QPropertyAnimation *>(m_moving->animationAt(i));
    move->setStartValue(QPoint(0, 0) - endpos);
  }
  setPos(pos() + endpos);

  /* start new animation */
  if (direction != m_direction)
  {
    if (direction == Actor::None)
      m_images[m_direction]->setVisible(true);
    else
      m_eating[direction]->start();
    m_direction = direction;
  }
  m_moving->start();
}

bool Actor::isMoving()
{
  return (m_moving->state() ==  QAbstractAnimation::Running);
}