#include "sceneholder.h"
#include "constants.h"
#include "pixmapitem.h"
#include "block.h"
#include "actor.h"
#include "bonuspoint.h"
#include "point.h"
#include "util.h"

SceneHolder::SceneHolder(QObject *parent)
  : QGraphicsScene(parent), m_color(Color::none), m_pointsLeft(0)
{
  setSceneRect(0, 0, Constants::map_size_pixel.width, Constants::map_size_pixel.height);
  setBackgroundBrush(Qt::black);

  visualMap.resize(Constants::map_size.width);
  for (int i = 0; i < visualMap.size(); ++i)
    visualMap[i].resize(Constants::map_size.height);
}

void SceneHolder::updateMap(const Transmission::map_t& map)
{
  for (unsigned int x = 0; x < Constants::map_size.width; ++x)
  {
    for (unsigned int y = 0; y < Constants::map_size.height; ++y)
    {
      const Transmission::field_t &cur = map[x][y];
      if (cur == Transmission::none)
        continue;

      Color::Color color = static_cast<Color::Color>(cur & Transmission::color_mask);
      PixmapItem* item = NULL;

      if (cur & Transmission::empty)
      {
        /* special handling for purging field */
        PixmapItem *oldItem = visualMap[x][y];
        /* remove elements (in case it's not an actor) */
        if (oldItem != NULL && dynamic_cast<Actor *>(item) == NULL)
        {
          removeItem(oldItem);
          visualMap[x][y] = NULL;
          Actor *actor = NULL;
          foreach (Actor *i, m_actors)
          {
            if (CoordToMapPosition(i->pos().toPoint()) == QPoint(x, y))
            {
              actor = i;
              break;
            }
          }
          oldItem->onDie(actor);
          delete oldItem;
          //qDebug() << "deleting " << x << y;
        }
      }

      if (cur == Transmission::none)
      {
        // no update
      }
      else if (cur & Transmission::block)
      {
        unsigned int neighbours = Block::None;
        // check left side
        if (x > 0 && map[x - 1][y] & Transmission::block)
          neighbours |= Block::Left;
        // check right side
        if (x < Constants::map_size.width && map[x + 1][y] & Transmission::block)
          neighbours |= Block::Right;
        // check upside
        if (y > 0 && map[x][y - 1] & Transmission::block)
          neighbours |= Block::Up;
        // check down side
        if (y < Constants::map_size.height && map[x][y + 1] & Transmission::block)
          neighbours |= Block::Down;
        item = new Block(color, neighbours);
      }
      else if (cur & Transmission::bonuspoint)
        item = new BonusPoint();
      else if (cur & Transmission::point)
      {
        item = new Point();
        connect(item, SIGNAL(destroyed()), this, SLOT(decrementPoints()));
        ++m_pointsLeft;
      }
      else if (cur & Transmission::pacman)
      {
        Actor *actor = m_actors.value(color, NULL);
        if (actor == NULL)
        {
          actor = new Actor(color, (color == m_color));
          m_actors[color] = actor;
          addItem(actor);
          actor->setPos(mapPositionToCoord(x, y));
        }
        else
        {
          Actor::Movement direction =
          Util::transmissionMovementToActor(cur & Transmission::direction_mask);
          actor->move(direction);
          qDebug() << "actor " << color << " move " << direction << "to " << x << y;
        }
      }
      else if (cur & Transmission::empty)
      {
        /* already handled */
      }
      else
      {
        qWarning() << "Unknown data value at" << cur;
        Q_ASSERT(false);
      }

      if (item != NULL)
      {
        addItem(item);
        item->setPos(mapPositionToCoord(x, y));
        PixmapItem* oldItem = visualMap[x][y];
        visualMap[x][y] = item;
        if (oldItem != NULL)
        {
          removeItem(item);
          delete oldItem;
        }
      }
    }
  }

}

void SceneHolder::setColor(Color::Color color)
{
  m_color = color;
}

Color::Color SceneHolder::color()
{
  return m_color;
}

unsigned int SceneHolder::pointsLeft()
{
  return m_pointsLeft;
}

void SceneHolder::decrementPoints()
{
  --m_pointsLeft;
  qDebug() << "points left=" << m_pointsLeft;
}

QPoint SceneHolder::mapPositionToCoord(unsigned int x, unsigned int y)
{
  return QPoint(x * Constants::field_size.width, y * Constants::field_size.height);
}

QPoint SceneHolder::mapPositionToCoord(QPoint point)
{
  return mapPositionToCoord(point.x(), point.y());
}

QPoint SceneHolder::CoordToMapPosition(unsigned int x, unsigned int y)
{
  return QPoint(x / Constants::field_size.width, y / Constants::field_size.height);
}

QPoint SceneHolder::CoordToMapPosition(QPoint point)
{
  return CoordToMapPosition(point.x(), point.y());
}