#pragma once
#include <vector>
#include "matrix.hpp"
#include <bitset>
#include <limits>
#include <optional>
#include <nlohmann/json.hpp>
#include "config.hpp"

namespace ai {
  constexpr const int SCORE_MAX = std::numeric_limits<int>::max();
  constexpr const size_t STATE_MAX = 32;

  using State = std::bitset<STATE_MAX>;

  const State ALL_ZERO;
  const State ALL_ONES = ~ALL_ZERO;

  struct Action {
    std::string $name;
    int $cost = 0;

    State $positive_preconds;
    State $negative_preconds;

    State $positive_effects;
    State $negative_effects;

    Action(std::string name, int cost) :
      $name(name), $cost(cost) { }

    void needs(int name, bool val);
    void effect(int name, bool val);

    bool can_effect(State& state);
    State apply_effect(State& state);

    bool operator==(const Action& other) const {
      return other.$name == $name;
    }
  };

  using Script = std::deque<Action>;

  const Action FINAL_ACTION("END", SCORE_MAX);

  struct ActionState {
    Action action;
    State state;

    ActionState(Action action, State state) :
      action(action), state(state) {}

    bool operator==(const ActionState& other) const {
      return other.action == action && other.state == state;
    }
  };

  bool is_subset(State& source, State& target);

  int distance_to_goal(State& from, State& to);

  std::optional<Script> plan_actions(std::vector<Action>& actions, State& start, State& goal);

  struct AIManager {
    nlohmann::json profile;

    std::unordered_map<std::string, Action> actions;
    std::unordered_map<std::string, State> states;
    std::unordered_map<std::string, std::vector<Action>> scripts;
  };

  void init();

  Action config_action(nlohmann::json& profile, nlohmann::json& config);
  State config_state(nlohmann::json& profile, nlohmann::json& config);

  int state_id(std::string name);
  State load_state(std::string state_name);
  Action load_action(std::string action_name);
  std::vector<Action> load_script(std::string script_name);

  std::optional<Script> plan(std::string script_name, State start, State goal);
}

template<> struct std::hash<ai::Action> {
  size_t operator()(const ai::Action& p) const {
    return std::hash<std::string>{}(p.$name);
  }
};

template<> struct std::hash<ai::ActionState> {
  size_t operator()(const ai::ActionState& p) const {
    return std::hash<ai::Action>{}(p.action) ^ std::hash<ai::State>{}(p.state);
  }
};