#include <catch2/catch_test_macros.hpp>
#include <fmt/core.h>
#include <nlohmann/json.hpp>
#include <fstream>
#include "pathing.hpp"
#include "matrix.hpp"
#include "ai.hpp"
#include "game_level.hpp"
#include <chrono>
#include <thread>
#include "rand.hpp"

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

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

TEST_CASE("multiple targets can path", "[pathing]") {
  GameDB::init();

  auto level = GameDB::create_level();
  auto& walls_original = level.map->$walls;
  auto walls_copy = walls_original;

  Pathing paths{matrix::width(walls_copy), matrix::height(walls_copy)};

  // first, put everything of this type as a target
  level.world->query<Position, Combat>(
    [&](const auto ent, auto& position, auto&) {
      if(ent != level.player) {
        paths.set_target(position.location);
      }
  });

  level.world->query<Collision>(
    [&](const auto ent, auto& collision) {
      if(collision.has && ent != level.player) {
        auto& pos = level.world->get<Position>(ent);
        walls_copy[pos.location.y][pos.location.x] = WALL_VALUE;
      }
  });

  paths.compute_paths(walls_copy);
  bool diag = Random::uniform<int>(0, 1);

  auto pos = GameDB::player_position().location;
  auto found = paths.find_path(pos, PATHING_TOWARD, diag);

  while(found == PathingResult::CONTINUE) {
    // fmt::println("\033[2J\033[1;1H");
    // matrix::dump(diag ? "diag" : "simple", paths.$paths, pos.x, pos.y);
    std::this_thread::sleep_for(200ms);
    found = paths.find_path(pos, PATHING_TOWARD, diag);
  }

  // fmt::println("\033[2J\033[1;1H");
  // matrix::dump(diag ? "diag" : "simple", paths.$paths, pos.x, pos.y);

  if(found == PathingResult::FOUND) {
    fmt::println("FOUND!");
  } else if(found == PathingResult::FAIL && !diag) {
    REQUIRE(found != PathingResult::FAIL);
  }
}

TEST_CASE("dijkstra algo test", "[pathing-old]") {
  json data = load_test_pathing("./tests/dijkstra.json");

  for(auto &test : data) {
    Matrix expected = test["expected"];
    Matrix walls = test["walls"];

    Pathing pathing(walls[0].size(), walls.size());

    pathing.$input = test["input"];

    REQUIRE(pathing.INVARIANT());
    pathing.compute_paths(walls);

    REQUIRE(pathing.INVARIANT());

    matrix::dump("PATHING RESULT", pathing.$paths);
    matrix::dump("PATHING EXPECTED", expected);
    REQUIRE(pathing.$paths == expected);
  }
}