#include <catch2/catch_test_macros.hpp>
#include "dbc.hpp"
#include "goap.hpp"
#include <iostream>

using namespace dbc;
using namespace ailol;
using namespace nlohmann;

TEST_CASE("worldstate works", "[goap]") {
  enum StateNames {
    ENEMY_IN_RANGE,
    ENEMY_DEAD
  };

  GOAPState goal;
  GOAPState start;
  std::vector<Action> actions;

  // start off enemy not dead and not in range
  start[ENEMY_DEAD] = false;
  start[ENEMY_IN_RANGE] = false;

  // end goal is enemy is dead
  goal[ENEMY_DEAD] = true;

  Action move_closer("move_closer", 10);
  move_closer.needs(ENEMY_IN_RANGE, false);
  move_closer.effect(ENEMY_IN_RANGE, true);

  REQUIRE(move_closer.can_effect(start));
  auto after_move_state = move_closer.apply_effect(start);
  REQUIRE(start[ENEMY_IN_RANGE] == false);
  REQUIRE(after_move_state[ENEMY_IN_RANGE] == true);
  REQUIRE(after_move_state[ENEMY_DEAD] == false);
  // start is clean but after move is dirty
  REQUIRE(move_closer.can_effect(start));
  REQUIRE(!move_closer.can_effect(after_move_state));
  REQUIRE(distance_to_goal(start, after_move_state) == 1);

  Action kill_it("kill_it", 10);
  kill_it.needs(ENEMY_IN_RANGE, true);
  kill_it.needs(ENEMY_DEAD, false);
  kill_it.effect(ENEMY_DEAD, true);

  REQUIRE(!kill_it.can_effect(start));
  REQUIRE(kill_it.can_effect(after_move_state));

  auto after_kill_state = kill_it.apply_effect(after_move_state);
  REQUIRE(!kill_it.can_effect(after_kill_state));
  REQUIRE(distance_to_goal(after_move_state, after_kill_state) == 1);

  actions.push_back(kill_it);
  actions.push_back(move_closer);

  REQUIRE(start != goal);
}

TEST_CASE("basic feature tests", "[goap]") {
  enum StateNames {
    ENEMY_IN_RANGE,
    ENEMY_DEAD
  };

  GOAPState goal;
  GOAPState start;
  std::vector<Action> actions;

  // start off enemy not dead and not in range
  start[ENEMY_DEAD] = false;
  start[ENEMY_IN_RANGE] = false;

  // end goal is enemy is dead
  goal[ENEMY_DEAD] = true;

  Action move_closer("move_closer", 10);
  move_closer.needs(ENEMY_IN_RANGE, false);
  move_closer.effect(ENEMY_IN_RANGE, true);

  Action kill_it("kill_it", 10);
  kill_it.needs(ENEMY_IN_RANGE, true);
  // this is duplicated on purpose to confirm that setting
  // a positive then a negative properly cancels out
  kill_it.needs(ENEMY_DEAD, true);
  kill_it.needs(ENEMY_DEAD, false);

  // same thing with effects
  kill_it.effect(ENEMY_DEAD, false);
  kill_it.effect(ENEMY_DEAD, true);

  // order seems to matter which is wrong
  actions.push_back(kill_it);
  actions.push_back(move_closer);

  auto result = plan_actions(actions, start, goal);
  REQUIRE(result != std::nullopt);

  auto state = start;

  for(auto& action : *result) {
    state = action.apply_effect(state);
  }

  REQUIRE(state[ENEMY_DEAD]);
}

TEST_CASE("wargame test from cppGOAP", "[goap]") {
  std::vector<Action> actions;
  auto profile = R"({
    "target_acquired": 0,
    "target_lost": 1,
    "target_in_warhead_range": 2,
    "target_dead": 3
  })"_json;

  // Now establish all the possible actions for the action pool
  // In this example we're providing the AI some different FPS actions
  Action spiral("searchSpiral", 5);
  auto config = R"({
    "needs": {
      "target_acquired": false,
      "target_lost": true
    },
    "effects": {
      "target_acquired": true
    }
  })"_json;
  spiral.load(profile, config);
  actions.push_back(spiral);

  Action serpentine("searchSerpentine", 5);
  config = R"({
    "needs": {
      "target_acquired": false,
      "target_lost": false
    },
    "effects": {
      "target_acquired": true
    }
  })"_json;
  serpentine.load(profile, config);
  actions.push_back(serpentine);

  Action intercept("interceptTarget", 5);
  config = R"({
    "needs": {
      "target_acquired": true,
      "target_dead": false
    },
    "effects": {
      "target_in_warhead_range": true
    }
  })"_json;
  intercept.load(profile, config);
  actions.push_back(intercept);


  Action detonateNearTarget("detonateNearTarget", 5);
  config = R"({
    "needs": {
      "target_in_warhead_range": true,
      "target_acquired": true,
      "target_dead": false
    },
    "effects": {
      "target_dead": true
    }
  })"_json;
  detonateNearTarget.load(profile, config);
  actions.push_back(detonateNearTarget);

  // Here's the initial state...
  GOAPState initial_state;
  initial_state[profile["target_acquired"]] = false;
  initial_state[profile["target_lost"]] = true;
  initial_state[profile["target_in_warhead_range"]] = false;
  initial_state[profile["target_dead"]] = false;

  // ...and the goal state
  GOAPState goal_target_dead;
  goal_target_dead[profile["target_dead"]] = true;

  auto result = plan_actions(actions, initial_state, goal_target_dead);
  REQUIRE(result != std::nullopt);

  auto state = initial_state;

  for(auto& action : *result) {
    fmt::println("ACTION: {}", action.$name);
    state = action.apply_effect(state);
  }

  REQUIRE(state[profile["target_dead"]]);
}