#include "Country.hpp"

#include <filesystem>
#include <string_view>
#include <system_error>
#include <unordered_map>
#include <vector>

#include <openvic-dataloader/v2script/AbstractSyntaxTree.hpp>

#include "openvic-simulation/GameManager.hpp"
#include "openvic-simulation/dataloader/Dataloader.hpp"
#include "openvic-simulation/dataloader/NodeTools.hpp"
#include "openvic-simulation/politics/Government.hpp"
#include "openvic-simulation/politics/Ideology.hpp"
#include "openvic-simulation/politics/Issue.hpp"
#include "openvic-simulation/pop/Culture.hpp"
#include "openvic-simulation/types/Colour.hpp"
#include "openvic-simulation/types/IdentifierRegistry.hpp"

using namespace OpenVic;
using namespace OpenVic::NodeTools;

std::string_view CountryParty::get_name() const {
	return name;
}

const Date& CountryParty::get_start_date() const {
	return start_date;
}

const Date& CountryParty::get_end_date() const {
	return end_date;
}

const Ideology& CountryParty::get_ideology() const {
	return ideology;
}

const std::vector<const Issue*>& CountryParty::get_policies() const {
	return policies;
}

CountryParty::CountryParty(
	std::string_view new_name, Date new_start_date, Date new_end_date, const Ideology& new_ideology,
	std::vector<const Issue*>&& new_policies
) : name { new_name }, start_date { new_start_date }, end_date { new_end_date }, ideology { new_ideology },
	policies { std::move(new_policies) } {}

std::string_view UnitNames::get_identifier() const {
	return identifier;
}

const std::vector<std::string>& UnitNames::get_names() const {
	return names;
}

UnitNames::UnitNames(std::string_view new_identifier, std::vector<std::string>&& new_names)
	: identifier { new_identifier }, names { std::move(new_names) } {}

const GraphicalCultureType& Country::get_graphical_culture() const {
	return graphical_culture;
}

const std::vector<CountryParty>& Country::get_parties() const {
	return parties;
}

const std::vector<UnitNames>& Country::get_unit_names() const {
	return unit_names;
}

const std::map<const GovernmentType*, colour_t>& Country::get_alternative_colours() const {
	return alternative_colours;
}

const bool Country::is_dynamic_tag() const {
	return dynamic_tag;
}

Country::Country(
	std::string_view new_identifier, colour_t new_color, const GraphicalCultureType& new_graphical_culture,
	std::vector<CountryParty>&& new_parties, std::vector<UnitNames>&& new_unit_names, bool new_dynamic_tag,
	std::map<const GovernmentType*, colour_t>&& new_alternative_colours
) : HasIdentifierAndColour(new_identifier, new_color, false, false), graphical_culture { new_graphical_culture },
	parties { std::move(new_parties) }, unit_names { std::move(new_unit_names) }, dynamic_tag { new_dynamic_tag },
	alternative_colours { std::move(new_alternative_colours) } {}

CountryManager::CountryManager() : countries { "countries" } {}

bool CountryManager::add_country(
	std::string_view identifier, colour_t color, const GraphicalCultureType& graphical_culture,
	std::vector<CountryParty>&& parties, std::vector<UnitNames>&& unit_names, bool dynamic_tag,
	std::map<const GovernmentType*, colour_t>&& alternative_colours
) {
	if (identifier.empty()) {
		return false;
	}

	return countries.add_item({
		identifier, color, graphical_culture, std::move(parties), std::move(unit_names),
		dynamic_tag, std::move(alternative_colours)
	});
}

bool CountryManager::load_country_data_file(
	GameManager& game_manager, std::string_view name, bool is_dynamic, ast::NodeCPtr root
) {
	colour_t color;
	const GraphicalCultureType* graphical_culture;
	std::vector<CountryParty> country_parties;
	std::vector<UnitNames> unit_names;
	std::map<const GovernmentType*, colour_t> alternative_colours;

	bool ret = expect_dictionary_keys_and_default(
		[&game_manager, &alternative_colours, &name](std::string_view key, ast::NodeCPtr value) -> bool {
			const GovernmentType* colour_gov_type;
			bool ret = game_manager.get_politics_manager().get_government_type_manager()
				.expect_government_type_str(assign_variable_callback_pointer(colour_gov_type))(key);

			if (!ret) {
				return false;
			}

			colour_t alternative_colour;
			ret &= expect_colour(assign_variable_callback(alternative_colour))(value);

			if (!ret) {
				return false;
			}

			return alternative_colours.emplace(std::move(colour_gov_type), std::move(alternative_colour)).second;
		},
		"color", ONE_EXACTLY, expect_colour(assign_variable_callback(color)),
		"graphical_culture", ONE_EXACTLY, expect_identifier_or_string(
			[&game_manager, &graphical_culture, &name](std::string_view value) -> bool {
				graphical_culture = game_manager.get_pop_manager().get_culture_manager()
					.get_graphical_culture_type_by_identifier(value);
				if (graphical_culture == nullptr) {
					Logger::error("When loading country ", name, ", specified graphical culture ", value,
						" is invalid!\nCheck that CultureManager has loaded before CountryManager.");
				}

				return graphical_culture != nullptr;
			}
		),
		"party", ZERO_OR_MORE, [&game_manager, &country_parties, &name](ast::NodeCPtr value) -> bool {
			std::string_view party_name;
			Date start_date, end_date;
			const Ideology* ideology;
			std::vector<const Issue*> policies;

			bool ret = expect_dictionary_keys_and_default(
				[&game_manager, &policies](std::string_view key, ast::NodeCPtr value) -> bool {
					const Issue* policy;
					bool ret = expect_identifier_or_string(
						game_manager.get_politics_manager().get_issue_manager().expect_issue_str(
							assign_variable_callback_pointer(policy)
						)
					)(value);

					if (ret && policy->get_group().get_identifier() == key) {
						policies.push_back(policy);
						return true;
					}

					return false;
				},
				"name", ONE_EXACTLY, expect_identifier_or_string(assign_variable_callback(party_name)),
				"start_date", ONE_EXACTLY, expect_date(assign_variable_callback(start_date)),
				"end_date", ONE_EXACTLY, expect_date(assign_variable_callback(end_date)),
				"ideology", ONE_EXACTLY, expect_identifier_or_string(game_manager.get_politics_manager()
					.get_ideology_manager().expect_ideology_str(assign_variable_callback_pointer(ideology)))
			)(value);

			country_parties.push_back({ party_name, start_date, end_date, *ideology, std::move(policies) });

			return ret;
		},
		"unit_names", ZERO_OR_ONE, expect_dictionary([&unit_names](std::string_view key, ast::NodeCPtr value) -> bool {
			std::vector<std::string> names;

			bool ret = expect_list(expect_identifier_or_string(
				[&names](std::string_view value) -> bool {
					names.push_back(std::string(value));
					return true;
				}
			))(value);

			unit_names.push_back({ key, std::move(names) });

			return ret;
		})
	)(root);

	ret &= add_country(
		name, color, *graphical_culture, std::move(country_parties), std::move(unit_names), is_dynamic,
		std::move(alternative_colours)
	);
	return ret;
}