#include "systems.hpp"
#include <fmt/core.h>
#include <string>
#include <cmath>
#include "rand.hpp"
#include "collider.hpp"

using std::string;
using namespace fmt;

using namespace Components;

void System::enemy_pathing(DinkyECS::World &world, Map &game_map, Player &player) {
  const auto &player_position = world.component<Position>(player.entity);
  game_map.set_target(player_position.location);
  game_map.make_paths();

  world.system<Position, Motion>([&](const auto &ent, auto &position, auto &motion) {
    if(ent != player.entity) {
      Point out = position.location;
      game_map.neighbors(out, false);
      motion = { int(out.x - position.location.x), int(out.y - position.location.y)};
    }
  });
  game_map.clear_target(player_position.location);
}

void System::init_positions(DinkyECS::World &world) {
  auto &collider = world.get<spatial_map>();

  world.system<Position>([&](const auto &ent, auto &pos) {
      collider.insert(pos.location, ent);
  });
}

inline void move_entity(spatial_map &collider, Map &game_map, Position &position, Motion &motion, DinkyECS::Entity ent) {
  Point move_to = {
    position.location.x + motion.dx,
    position.location.y + motion.dy
  };
  motion = {0,0}; // clear it after getting it

  if(game_map.inmap(move_to.x, move_to.y) &&
      !game_map.iswall(move_to.x, move_to.y) &&
      !collider.occupied(move_to))
  {
    collider.move(position.location, move_to, ent);
    position.location = move_to;
  }
}

void System::motion(DinkyECS::World &world, Map &game_map) {
  auto &collider = world.get<spatial_map>();
  auto &player = world.get<Player>();
  auto &player_position = world.component<Position>(player.entity);
  auto &player_motion = world.component<Motion>(player.entity);
  move_entity(collider, game_map, player_position, player_motion, player.entity);

  world.system<Position, Motion>([&](const auto &ent, auto &position, auto &motion) {
    // don't process entities that don't move
    if(motion.dx != 0 || motion.dy != 0) {
      move_entity(collider, game_map, position, motion, ent);
    }
  });
}


void System::combat(DinkyECS::World &world, Player &player) {
  auto& collider = world.get<spatial_map>();
  const auto& player_position = world.component<Position>(player.entity);
  auto& player_combat = world.component<Combat>(player.entity);
  auto& log = world.get<ActionLog>();

  // this is guaranteed to not return the given position
  auto [found, nearby] = collider.neighbors(player_position.location);

  if(found) {
    for(auto entity : nearby) {
      auto& enemy_combat = world.component<Combat>(entity);
      int player_dmg = Random::uniform<int>(1, enemy_combat.damage);
      enemy_combat.hp -= player_dmg;
      log.log(format("YOU HIT {} damage! Enemy has {} HP left.",
            player_dmg, enemy_combat.hp));

      if(enemy_combat.hp <= 0) {
        log.log("--- ENEMY DEAD!---");
        auto enemy_position = world.component<Position>(entity);
        collider.remove(enemy_position.location);
        world.remove<Motion>(entity);
      } else {
        int attack = Random::uniform<int>(0,1);
        if(attack) {
          int dmg = Random::uniform<int>(1, enemy_combat.damage);
          player_combat.hp -= dmg;
          log.log(format("HIT! You took {} damage.", dmg));
        } else {
          log.log("You dodged! Run!");
        }
      }
    }
  }
};

void System::draw_entities(DinkyECS::World &world, Map &game_map, ftxui::Canvas &canvas, const Point &cam_orig, size_t view_x, size_t view_y) {
  world.system<Position, Tile>([&](const auto &ent, auto &pos, auto &tile) {
    if(pos.location.x >= cam_orig.x && pos.location.x <= cam_orig.x + view_x
        && pos.location.y >= cam_orig.y && pos.location.y <= cam_orig.y + view_y) {
      Point loc = game_map.map_to_camera(pos.location, cam_orig);
      // the 2 and 4 are from ftxui::Canvas since it does a kind of "subpixel" drawing
      canvas.DrawText(loc.x*2, loc.y*4, tile.chr);
    }
  });
}

void System::draw_map(DinkyECS::World &world, Map &game_map, ftxui::Canvas &canvas, size_t view_x, size_t view_y) {
  const auto& player = world.get<Player>();
  const auto& player_position = world.component<Position>(player.entity);
  Point start = game_map.center_camera(player_position.location, view_x, view_y);
  Matrix &walls = game_map.walls();

  size_t end_x = std::min(view_x, game_map.width() - start.x);
  size_t end_y = std::min(view_y, game_map.height() - start.y);

  for(size_t x = 0; x < end_x; ++x) {
    for(size_t y = 0; y < end_y; ++y) {
      string tile = walls[start.y+y][start.x+x] == 1 ? WALL_TILE : FLOOR_TILE;
      // the 2 and 4 are from ftxui::Canvas since it does a kind of "subpixel" drawing
      canvas.DrawText(x * 2, y * 4, tile);
    }
  }

  System::draw_entities(world, game_map, canvas, start, view_x, view_y);
}