#include "character_system.h"
#include "consts.h"
#include "mixer.h"
#include "sprite.h"
#include "game.h"
#include "transform_system.h"
#include "animation_system.h"

void CharacterSystem::initSprite(int spriteId) {
  Sprite& sprite = game_.getSprite(spriteId);
  sprite.orientable = true;
}

void CharacterSystem::addSpriteToParty(int leaderId, int followerId) {
  Sprite& leader = game_.getSprite(leaderId);
  Sprite& follower = game_.getSprite(followerId);

  int index = leader.followers.size() + 1;
  follower.trail = std::deque<Movement>(PARTY_FRAME_DELAY * index, {.pos = follower.loc, .dir = follower.dir});

  leader.followers.push_back(followerId);

  game_.getSystem<AnimationSystem>().setSpriteAnimation(followerId, "still");
}

void CharacterSystem::moveInDirection(int spriteId, Direction dir) {
  Sprite& sprite = game_.getSprite(spriteId);

  game_.getSystem<AnimationSystem>().setSpriteDirection(spriteId, dir);

  if (sprite.characterState == CharacterState::Still) {
    setPartyState(spriteId, CharacterState::Walking);
  } else if (sprite.characterState == CharacterState::Crouching) {
    for (int followerId : sprite.followers) {
      game_.getSystem<AnimationSystem>().setSpriteDirection(followerId, dir);
    }
  }
}

void CharacterSystem::stopDirecting(int spriteId) {
  Sprite& sprite = game_.getSprite(spriteId);

  if (sprite.characterState == CharacterState::Walking) {
    setPartyState(spriteId, CharacterState::Still);
  }
}

void CharacterSystem::tick(double dt) {
  inputTimer_.accumulate(dt);
  while (inputTimer_.step()) {
    for (int spriteId : game_.getSprites()) {
      Sprite& sprite = game_.getSprite(spriteId);

      if (sprite.orientable) {
        vec2i pLoc = sprite.loc;

        if (sprite.characterState == CharacterState::Still ||
            sprite.characterState == CharacterState::Crouching) {
          continue;
        }

        int speed = MOVEMENT_SPEED;
        if (sprite.characterState == CharacterState::Running) {
          speed *= 2;
        }

        pLoc += (unitVecInDirection(sprite.dir) * speed);

        // Check collision.
        const Map& map = game_.getMap();
        bool blocked = false;

        const vec2i UL_COL_BOX = { 8, 8 };
        const vec2i DR_COL_BOX = { 4, 0 };
        vec2i oldColPosUL = (sprite.loc - UL_COL_BOX) / map.getTileSize();
        vec2i newColPosUL = (pLoc - UL_COL_BOX) / map.getTileSize();
        vec2i oldColPosDR = (sprite.loc + DR_COL_BOX) / map.getTileSize();
        vec2i newColPosDR = (pLoc + DR_COL_BOX) / map.getTileSize();

        if (dirHasDir(sprite.dir, Direction::right) &&
            newColPosDR.x() > oldColPosDR.x()) {
          for (int y = newColPosUL.y(); y <= newColPosDR.y(); y++) {
            if (map.isBlocked(newColPosDR.x(), y)) {
              blocked = true;
              pLoc.x() = sprite.loc.x();//(newColPosDR * map.getTileSize() - (collisionBox / 2)).x() - 1;
              break;
            }
          }
        }

        if (dirHasDir(sprite.dir, Direction::left) &&
            newColPosUL.x() < oldColPosUL.x()) {
          for (int y = newColPosUL.y(); y <= newColPosDR.y(); y++) {
            if (map.isBlocked(newColPosUL.x(), y)) {
              blocked = true;
              pLoc.x() = sprite.loc.x();//(newColPosDR * map.getTileSize() - (collisionBox / 2)).x() - 1;
              break;
            }
          }
        }

        if (dirHasDir(sprite.dir, Direction::down) &&
            newColPosDR.y() > oldColPosDR.y()) {
          for (int x = newColPosUL.x(); x <= newColPosDR.x(); x++) {
            if (map.isBlocked(x, newColPosDR.y())) {
              blocked = true;
              pLoc.y() = sprite.loc.y();//(newColPosDR * map.getTileSize() - (collisionBox / 2)).x() - 1;
              break;
            }
          }
        }

        if (dirHasDir(sprite.dir, Direction::up) &&
            newColPosUL.y() < oldColPosUL.y()) {
          for (int x = newColPosUL.x(); x <= newColPosDR.x(); x++) {
            if (map.isBlocked(x, newColPosUL.y())) {
              blocked = true;
              pLoc.y() = sprite.loc.y();//(newColPosDR * map.getTileSize() - (collisionBox / 2)).x() - 1;
              break;
            }
          }
        }

        if (blocked && sprite.characterState == CharacterState::Running) {
          stopRunning(spriteId);
          game_.getMixer().playSound("../res/bump.wav");
        }

        // Move everything
        if (pLoc != sprite.loc) {
          game_.getSystem<TransformSystem>().moveSprite(spriteId, pLoc);

          for (int followerId : sprite.followers) {
            Sprite& pNext = game_.getSprite(followerId);
            const Movement& posdir = pNext.trail.front();
            game_.getSystem<TransformSystem>().moveSprite(followerId, posdir.pos);
            game_.getSystem<AnimationSystem>().setSpriteDirection(followerId, posdir.dir);

            pNext.trail.pop_front();
            pNext.trail.push_back({.pos = pLoc, .dir = sprite.dir});
          }
        }
      }
    }
  }
}

void CharacterSystem::beginCrouch(int spriteId) {
  Sprite& sprite = game_.getSprite(spriteId);

  if (sprite.characterState == CharacterState::Running) {
    stopRunning(spriteId);
  } else {
    setPartyState(spriteId, CharacterState::Crouching);
  }
}

void CharacterSystem::endCrouch(int spriteId) {
  Sprite& sprite = game_.getSprite(spriteId);

  if (sprite.characterState == CharacterState::Crouching) {
    setPartyState(spriteId, CharacterState::Running);

    for (int followerId : sprite.followers) {
      // Halve the movement buffer for the followers.
      Sprite& follower = game_.getSprite(followerId);
      std::deque<Movement> newMove;

      while (!follower.trail.empty()) {
        newMove.push_back(follower.trail.front());
        follower.trail.pop_front();
        follower.trail.pop_front();
      }

      follower.trail = std::move(newMove);
    }
  }
}

void CharacterSystem::stopRunning(int spriteId) {
  Sprite& sprite = game_.getSprite(spriteId);
  setPartyState(spriteId, CharacterState::Still);

  // Double the movement buffer for the followers.
  for (int followerId : sprite.followers) {
    Sprite& follower = game_.getSprite(followerId);

    std::deque<Movement> newMove;
    vec2i lastPos = follower.loc;

    while (!follower.trail.empty()) {
      Movement m1 = follower.trail.front();
      Movement m2 = m1;
      m1.pos = (m1.pos + lastPos) / 2;
      lastPos = m2.pos;

      newMove.push_back(m1);
      newMove.push_back(m2);
      follower.trail.pop_front();
    }

    follower.trail = std::move(newMove);
  }
}

void CharacterSystem::setPartyState(int spriteId, CharacterState state) {
  std::string animName;
  switch (state) {
    case CharacterState::Still: {
      animName = "still";
      break;
    }
    case CharacterState::Walking: {
      animName = "walk";
      break;
    }
    case CharacterState::Crouching: {
      animName = "crouch";
      break;
    }
    case CharacterState::Running: {
      animName = "run";
      break;
    }
  }

  Sprite& sprite = game_.getSprite(spriteId);
  sprite.characterState = state;

  game_.getSystem<AnimationSystem>().setSpriteAnimation(spriteId, animName);
  for (int followerId : sprite.followers) {
    game_.getSystem<AnimationSystem>().setSpriteAnimation(followerId, animName);
  }
}