#include "dinkyecs.hpp"

#include <iostream>
#include <fmt/core.h>

using namespace fmt;
using DinkyECS::Entity;

struct Player {
  std::string name;
  Entity eid;
};

struct Position {
  double x, y;
};

struct Velocity {
  double x, y;
};

struct Gravity {
  double level;
};

/*
 * Using a function catches instances where I'm not copying
 * the data into the world.
 */
void configure(DinkyECS::World &world, Entity &test) {
  println("---Configuring the base system.");
  Entity test2 = world.entity();

  world.set<Position>(test, {10,20});
  world.set<Velocity>(test, {1,2});

  world.set<Position>(test2, {1,1});
  world.set<Velocity>(test2, {10,20});

  println("---- Setting up the player as a fact in the system.");

  auto player_eid = world.entity();
  Player player_info{"Zed", player_eid};
  // just set some player info as a fact with the entity id
  world.set_the<Player>(player_info);

  world.set<Velocity>(player_eid, {0,0});
  world.set<Position>(player_eid, {0,0});

  auto enemy = world.entity();
  world.set<Velocity>(enemy, {0,0});
  world.set<Position>(enemy, {0,0});

  println("--- Creating facts (singletons)");
  world.set_the<Gravity>({0.9});
}

int main() {
  DinkyECS::World world;
  Entity test = world.entity();

  configure(world, test);

  Position &pos = world.get<Position>(test);
  println("GOT POS x={}, y={}", pos.x, pos.y);

  Velocity &vel = world.get<Velocity>(test);
  println("GOT VELOCITY x={}, y={}", vel.x, vel.y);

  println("--- Position only system:");
  world.query<Position>([](const auto &ent, auto &pos) {
      println("entity={}, pos.x={}, pos.y={}", ent, pos.x, pos.y);
  });

  println("--- Velocity only system:");
  world.query<Velocity>([](const auto &, auto &vel) {
      println("vel.x={}, vel.y={}", vel.x, vel.y);
  });

  println("--- Manually get the velocity in position system:");
  world.query<Position>([&](const auto &ent, auto &pos) {
      Velocity &vel = world.get<Velocity>(ent);
      println("entity={}, vel.x, vel.y, pos.x={}, pos.y={}", ent, vel.x, vel.y, pos.x, pos.y);
  });

  println("--- Query only entities with Position and Velocity:");
  world.query<Position, Velocity>([&](const auto &ent, auto &pos, auto &vel) {
      Gravity &grav = world.get_the<Gravity>();
      println("grav={}, entity={}, vel.x, vel.y, pos.x={}, pos.y={}", grav.level, ent, vel.x, vel.y, pos.x, pos.y);
  });

  // now remove Velocity
  world.remove<Velocity>(test);

  println("--- After remove test, should only result in test2:");
  world.query<Position, Velocity>([&](const auto &ent, auto &pos, auto &vel) {
      println("entity={}, vel.x, vel.y, pos.x={}, pos.y={}", ent, vel.x, vel.y, pos.x, pos.y);
  });

  // to avoid repeatedly getting the player just make a closure with it
  // QUESTION: could I just capture it and not have the double function wrapping?
  auto playerVsEnemies = [&]() {
    auto& player = world.get_the<Player>(); // grabbed it
    world.query<Position>([&](const auto &ent, auto &pos) {
      if(player.eid != ent) {
        println("{} is enemy attacking player {}", ent, player.name);
      } else {
        println("{} is player", player.name);
      }
    });
  };

  playerVsEnemies();

  return 0;
}