#include <kurator/battles/Battle.h>

#include <cmath>
#include <memory>
#include <random>

#include <entt/entity/registry.hpp>

#include <kurator/battles/components.h>
#include <kurator/battles/Scenario.h>
#include <kurator/universe/ShipType.h>

#include "RandomSpawner.h"


namespace kurator
{
namespace battles
{


int total_teams_in(const Scenario& scenario);


class BaseBattle : public Battle
{
public:
	BaseBattle(const Scenario& scenario);
	entt::registry& registry() override;
	void update(float dt) override;
private:
	entt::registry _registry;
	RandomSpawner spawner;
};


BaseBattle::BaseBattle(const Scenario& scenario) :
	_registry {},
	spawner {total_teams_in(scenario), 2.5, 0.1}
{
	for (const auto& ship : scenario.ships) {
		const auto entity = _registry.create();
		_registry.emplace<universe::ShipType>(entity, ship.type);
		_registry.emplace<Team>(entity, ship.team);
		_registry.emplace<Transform>(entity, spawner.get(ship.team));
	}
}


entt::registry&
BaseBattle::registry()
{
	return _registry;
}


void
BaseBattle::update(const float dt)
{
	auto view = _registry.view<Transform>();
	for (auto&& [entity, transform] : view.each()) {
		transform.position.x += 0.1 * dt * std::cos(transform.angle);
		transform.position.y += 0.1 * dt * std::sin(transform.angle);
	}
}


std::unique_ptr<Battle>
prepare(const Scenario& scenario)
{
	return std::make_unique<BaseBattle>(scenario);
}


int
total_teams_in(const Scenario& scenario)
{
	int last_team = 0;
	for (const auto& ship : scenario.ships) {
		if (ship.team > last_team)
			last_team = ship.team;
	}
	return last_team + 1;
}


}  // namespace battles
}  // namespace kurator