#include "JsonRepository.h"

#include <fstream>
#include <functional>
#include <map>
#include <stdexcept>
#include <string>

#include <nlohmann/json.hpp>

#include <kurator/universe/NotFound.h>
#include <kurator/universe/ShipType.h>
#include <kurator/universe/TurretType.h>


using json = nlohmann::json;


namespace kurator
{
namespace universe
{


void
from_json(const json& item, ShipType& ship)
{
	item.at("name").get_to(ship.name);
	item.at("base_structure_points").get_to(ship.base_structure_points);
	item.at("base_armour_points").get_to(ship.base_armour_points);
	item.at("base_shield_points").get_to(ship.base_shield_points);
	item.at("max_speed").get_to(ship.max_speed);
}


void
from_json(const json& item, TurretType& turret)
{
	item.at("name").get_to(turret.name);
	if (item.contains("base_damage"))
		item.at("base_damage").get_to(turret.base_damage);
	if (item.contains("rounds"))
		item.at("rounds").get_to(turret.rounds);
	if (item.contains("rate_of_fire"))
		item.at("rate_of_fire").get_to(turret.rate_of_fire);
	if (item.contains("reload"))
		item.at("reload").get_to(turret.reload);
	if (item.contains("optimal_range"))
		item.at("optimal_range").get_to(turret.optimal_range);
	if (item.contains("falloff_modifier"))
		item.at("falloff_modifier").get_to(turret.falloff_modifier);
	if (item.contains("falloff_intensity"))
		item.at("falloff_intensity").get_to(turret.falloff_intensity);
}


template<typename Type>
std::map<std::string, Type>
parse(const std::string& path)
try {
	std::fstream file{path, file.binary | file.in};  // std::filesystem?
	if (!file.is_open())
		throw "could not load universe part";  // FIXME: proper errors and handling above
	std::map<std::string, Type> map;
	const auto root = json::parse(file);
	for (const auto& item : root) {
		auto def = item.get<Type>();
		map[def.name] = def;
	}
	return map;
}
catch (const json::parse_error&) {
	throw;
}


JsonRepository::JsonRepository(const std::string& path)
{
	ships = parse<ShipType>(path + "/ship_types.json");
	turrets = parse<TurretType>(path + "/turret_types.json");
}


ShipType
JsonRepository::ship_type(const std::string& id) const
try {
	return ships.at(id);
}
catch (const std::out_of_range&) {
	throw NotFound(id);
}


TurretType
JsonRepository::turret_type(const std::string& id) const
try {
	return turrets.at(id);
}
catch (const std::out_of_range&) {
	throw NotFound(id);
}


void
JsonRepository::for_ship_types(std::function<void(const ShipType&)> func) const
{
	for (const auto& [_, type] : ships)
		func(type);
}


void
JsonRepository::for_turret_types(std::function<void(const TurretType&)> func) const
{
	for (const auto& [_, type] : turrets)
		func(type);
}


}  // namespace universe
}  // namespace kurator