#include <catch2/catch_test_macros.hpp>
#include <fmt/core.h>
#include <nlohmann/json.hpp>
#include <fstream>
#include "map.hpp"
#include "levelmanager.hpp"

using namespace fmt;
using namespace nlohmann;
using std::string;

json load_test_data(const string &fname) {
  std::ifstream infile(fname);
  return json::parse(infile);
}

TEST_CASE("camera control", "[map]") {
  textures::init();
  components::init();
  LevelManager levels;
  GameLevel level = levels.current();
  auto &map = *level.map;

  Point center = map.center_camera({10,10}, 5, 5);

  map.dump(center.x, center.y);
  REQUIRE(center.x == 8);
  REQUIRE(center.y == 8);

  Point translation = map.map_to_camera({10,10}, center);

  REQUIRE(translation.x == 2);
  REQUIRE(translation.y == 2);
}

TEST_CASE("map placement test", "[map:placement]") {
  textures::init();
  components::init();
  for(int i = 0; i < 20; i++) {
    LevelManager levels;
    GameLevel level = levels.current();
    auto &map = *level.map;

    for(size_t rnum = 0; rnum < map.room_count(); rnum++) {
      Point pos;

      REQUIRE(map.place_entity(rnum, pos));

      REQUIRE(!map.iswall(pos.x, pos.y));
      REQUIRE(map.inmap(pos.x, pos.y));
    }
  }
}

TEST_CASE("dijkstra algo test", "[map]") {
  textures::init();
  json data = load_test_data("./tests/dijkstra.json");

  for(auto &test : data) {
    Matrix expected = test["expected"];
    Matrix input = test["input"];
    Matrix walls = test["walls"];
    Map map(input.size(), input[0].size());
    map.$walls = walls;
    map.$paths.$input = input;

    REQUIRE(map.INVARIANT());

    map.make_paths();
    Matrix &paths = map.paths();

    if(paths != expected) {
      println("ERROR! ------");
      matrix::dump("EXPECTED", expected);
      matrix::dump("RESULT", paths);
    }

    REQUIRE(map.INVARIANT());
    // FIX ME: REQUIRE(paths == expected);
  }
}

sf::Sprite render_map(GameLevel& level, sf::RenderTexture& render) {
  auto &walls = level.map->tiles();

  auto &tile_set = textures::get_map_tile_set();

  sf::Vector2i size{MAP_TILE_DIM,MAP_TILE_DIM};

  sf::Vector2u dim{
    (unsigned int)matrix::width(walls) * size.x,
    (unsigned int)matrix::height(walls) * size.y};

  bool worked = render.resize(dim);
  dbc::check(worked, "Failed to resize map render target.");

  render.clear({0,0,0,0});

  for(matrix::each_row it{walls}; it.next();) {
    size_t tid = walls[it.y][it.x];
    wchar_t display = tile_set[tid];

    auto& sprite = textures::get_map_sprite(display);
    sprite.setPosition({float(it.x * size.x), float(it.y * size.y)});
    render.draw(sprite);
  }

  render.display();
  return sf::Sprite{render.getTexture()};
}

sf::Sprite render_entities(GameLevel& level, sf::Sprite& map_sprite, sf::RenderTexture& render) {
  render.clear({0,0,0,0});
  render.draw(map_sprite);

  level.world->query<components::Position, components::Tile>([&](auto, auto &pos, auto &entity_glyph) {
    auto sprite = textures::get_map_sprite(entity_glyph.display);
    sprite.setPosition({float(pos.location.x * MAP_TILE_DIM), float(pos.location.y * MAP_TILE_DIM)});
    render.draw(sprite);
  });

  render.display();
  return sf::Sprite{render.getTexture()};
}

TEST_CASE("map image test", "[map-sprite]") {
  components::init();
  textures::init();

  LevelManager levels;
  GameLevel level = levels.current();
  // on level start make one render texture with the base map
  auto render = std::make_shared<sf::RenderTexture>();
  auto map_sprite = render_map(level, *render);

  // every turn render the map to the entities texture, then render
  // entities on this image, that way I just have to render them
  auto entities = std::make_shared<sf::RenderTexture>(render->getSize());
  render_entities(level, map_sprite, *entities);

  // confirm we get two different maps
  auto out_img = render->getTexture().copyToImage();
  bool worked = out_img.saveToFile("map_render.png");
  REQUIRE(worked);

  // this has entities on it
  out_img = entities->getTexture().copyToImage();
  worked = out_img.saveToFile("map_entities.png");
  REQUIRE(worked);
}