#include "BaseBattle.h"

#include <cmath>
#include <memory>

#include <entt/entity/registry.hpp>

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


namespace kurator
{
namespace battles
{


int total_teams_in(const Scenario& scenario);


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));
		_registry.emplace<FloatingMovement>(entity, 0.4);
		_registry.emplace<AIState>(entity, Point{0.0, 0.0});
	}
}


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


void
BaseBattle::update(const float dt)
{
	auto view = _registry.view<Transform, AIState, FloatingMovement>();
	for (auto&& [entity, transform, state, movement] : view.each()) {
		const double speed = movement.speed * dt;
		const Point diff = (state.destination - transform.position);
		if (diff.magnitude() > speed) {
			const Point eff = diff.normalized().scale(speed);
			transform.position.x += eff.x;
			transform.position.y += eff.y;
		}
	}
}


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