#include "Codegen.hpp"

#include <bit> // IWYU pragma: keep
#include <cctype>
#include <charconv>
#include <cstring>
#include <string_view>
#include <unordered_map>
#include <variant>

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

#include <tsl/ordered_map.h>

#include <dryad/_detail/assert.hpp>
#include <dryad/node.hpp>
#include <dryad/tree.hpp>

#include <range/v3/algorithm/equal.hpp>
#include <range/v3/algorithm/reverse.hpp>

#include "GameManager.hpp"
#include "types/fixed_point/FixedPoint.hpp"
#include "vm/Builtin.hpp"
#include <lauf/asm/builder.h>
#include <lauf/asm/module.h>
#include <lauf/runtime/builtin.h>
#include <lauf/runtime/memory.h>
#include <lauf/runtime/process.h>
#include <lauf/runtime/value.h>

using namespace OpenVic::Vm;
using namespace ovdl::v2script::ast;
using namespace ovdl::v2script;

using namespace std::string_view_literals;

bool ichar_equals(char a, char b) {
	return std::tolower(static_cast<unsigned char>(a)) == std::tolower(static_cast<unsigned char>(b));
}

Codegen::Codegen(
	ovdl::v2script::Parser const& parser, OpenVic::GameManager* game_manager, const char* module_name,
	lauf_asm_build_options options
)
	: _parser(parser), _game_manager(game_manager), _module(module_name), _builder(options) {}

Codegen::Codegen(
	ovdl::v2script::Parser const& parser, OpenVic::GameManager* game_manager, Module&& module, AsmBuilder&& builder
)
	: _parser(parser), _game_manager(game_manager), _module(std::move(module)), _builder(std::move(builder)) {}

static constexpr auto any_ = "any_"sv;
static constexpr auto all_ = "all_"sv;
static constexpr auto war_countries = "war_countries"sv;

bool Codegen::is_iterative_scope(scope_execution_type execution_type, scope_type active_scope_type, ovdl::symbol<char> name)
	const {
	return std::strncmp(name.c_str(), any_.data(), any_.size()) == 0 ||
		std::strncmp(name.c_str(), all_.data(), all_.size()) == 0 ||
		std::strncmp(name.c_str(), war_countries.data(), war_countries.size()) == 0;
}

Codegen::scope_type Codegen::get_scope_type_for(scope_execution_type execution_type, ovdl::symbol<char> name) const {
	using enum scope_type;

	if (!name) {
		return None;
	}

#define FIND_SCOPE(SCOPE_TYPE, NAME) \
	if (_parser.find_intern(#NAME##sv) == name) \
	return SCOPE_TYPE

	FIND_SCOPE(Generic, this);
	FIND_SCOPE(Generic, from);

	// Country and Pop Scope
	FIND_SCOPE(Country | Pop, cultural_union);

	// Country Scope
	FIND_SCOPE(Country, capital_scope);
	FIND_SCOPE(Country, overlord);
	FIND_SCOPE(Country, sphere_owner);
	// Country Scope Random
	FIND_SCOPE(Country, random_country);
	FIND_SCOPE(Country, random_owned);
	FIND_SCOPE(Country, random_pop);
	// Country Scope Iterative
	FIND_SCOPE(Country, all_core);
	FIND_SCOPE(Country, any_country);
	FIND_SCOPE(Country, any_core);
	FIND_SCOPE(Country, any_greater_power);
	FIND_SCOPE(Country, any_neighbor_country);
	FIND_SCOPE(Country, any_owned_province);
	FIND_SCOPE(Country, any_pop);
	FIND_SCOPE(Country, any_sphere_member);
	FIND_SCOPE(Country, any_state);
	FIND_SCOPE(Country, any_substate);
	FIND_SCOPE(Country, war_countries);

	// Province Scope
	FIND_SCOPE(Province, controller);
	FIND_SCOPE(Province, owner);
	FIND_SCOPE(Province, state_scope);
	// Province Scope Random
	FIND_SCOPE(Province, random_neighbor_province);
	FIND_SCOPE(Province, random_empty_neighbor_province);
	// Province Scope Iterative
	FIND_SCOPE(Province, any_core);
	FIND_SCOPE(Province, any_neighbor_province);
	FIND_SCOPE(Province, any_pop);

	// Pop Scope
	FIND_SCOPE(Pop, country);
	FIND_SCOPE(Pop, location);

#undef FIND_SCOPE
	return None;
}

OpenVic::Asm::scope_store_variant Codegen::get_static_scope( //
	scope_execution_type execution_type, scope_type active_scope_type, ovdl::symbol<char> name
) const {
	auto name_sv = name.view();

	auto country =
		_game_manager->get_definition_manager().get_country_definition_manager().get_country_definition_by_identifier(name_sv);
	if (country != nullptr) {
		return country;
	}

	auto state_region = _game_manager->get_definition_manager().get_map_definition().get_region_by_identifier(name_sv);
	if (state_region != nullptr) {
		return state_region;
	}

	auto province = _game_manager->get_definition_manager().get_map_definition().get_province_definition_by_identifier(name_sv);
	if (province != nullptr) {
		return province;
	}

	return {};
}

static constexpr auto random_ = "random_"sv;

bool Codegen::supports_limit(scope_execution_type execution_type, scope_type active_scope_type, ovdl::symbol<char> name) const {
	if (is_iterative_scope(execution_type, active_scope_type, name)) {
		return true;
	}

	if (std::strncmp(name.c_str(), random_.data(), random_.size()) == 0) {
		return true;
	}

	// TODO: decide limit support
	return false;
}

void Codegen::generate_effect_from(scope_type type, const Node* node) {
	struct current_scope_t {
		scope_type type;
		ovdl::symbol<char> symbol;
	} current_scope { .type = type, .symbol = {} };

	bool is_arguments = false;
	std::unordered_map<ovdl::symbol<char>, const Node*, symbol_hash> named_arguments;
	Asm::argument::type_t ov_asm_type;

	dryad::visit_tree(
		node, //
		[&](dryad::child_visitor<NodeKind> visitor, const AssignStatement* statement) {
			using enum Codegen::scope_execution_type;

			const auto* left = dryad::node_try_cast<FlatValue>(statement->left());
			if (!left) {
				return;
			}

			const auto* right = dryad::node_try_cast<FlatValue>(statement->right());
			if (is_arguments) {
				if (right) {
					named_arguments.insert_or_assign(left->value(), right);
					return;
				} else if (supports_limit(Effect, current_scope.type, current_scope.symbol) &&
						   _parser.find_intern("limit"sv) == left->value()) {
					named_arguments.insert_or_assign(left->value(), statement->right());
					return;
				}

				// Boils war's attacker_goal = { casus_belli = [casus belli] } down to attacker_goal = [casus belli]
				if (auto right_list = dryad::node_try_cast<ListValue>(statement->right())) {
					if (right_list->statements().empty()) {
						return;
					}
					if (auto right_statement = dryad::node_try_cast<AssignStatement>(right_list->statements().front())) {
						if (auto right_flat_value = dryad::node_try_cast<FlatValue>(right_statement->right())) {
							named_arguments.insert_or_assign(left->value(), right_flat_value);
						}
					}
				}
				return;
			}

			bool is_iterative = false;
			lauf_asm_local* arguments = nullptr;

			if (!right) {
				if (_parser.find_intern("random"sv) == left->value()) {
					// TODO: implement random
					return;
				}

				if (_parser.find_intern("random_list"sv) == left->value()) {
					// TODO: implement random_list
					return;
				}

				is_arguments = current_scope.type >> get_scope_type_for(Effect, left->value());
				if (!is_arguments) {
					current_scope_t previous_scope = current_scope;
					current_scope.symbol = left->value();
					visitor(right);
					current_scope = previous_scope;
					return;
				}

				is_iterative = is_iterative_scope(Effect, current_scope.type, current_scope.symbol);
				if (is_iterative) {
					// TODO: loop header
				}

				arguments = lauf_asm_build_local(
					*this, lauf_asm_array_layout(LAUF_ASM_NATIVE_LAYOUT_OF(Asm::argument), named_arguments.size())
				);

				std::size_t index = 0;
				for (auto&& [key, value] : named_arguments) {
					inst_store_ov_asm_key(arguments, index, key);

					visitor(value);
					inst_store_ov_asm_value_from_vstack(arguments, index, ovdl::detail::to_underlying(ov_asm_type));

					inst_store_ov_asm_type(arguments, index, ovdl::detail::to_underlying(ov_asm_type));
					index++;
				}

				named_arguments.clear();
				is_arguments = false;
			} else if (auto yes_symbol = _parser.find_intern("yes"sv); yes_symbol && right->value() == yes_symbol) {
				// Build empty arguments
				arguments = lauf_asm_build_local(*this, lauf_asm_array_layout(LAUF_ASM_NATIVE_LAYOUT_OF(Asm::argument), 0));
			} else if (_parser.find_intern("no"sv) != right->value()) {
				arguments = lauf_asm_build_local(*this, lauf_asm_array_layout(LAUF_ASM_NATIVE_LAYOUT_OF(Asm::argument), 1));
				inst_store_ov_asm_key_null(arguments, 0);

				visitor(right);
				inst_store_ov_asm_value_from_vstack(arguments, 0, ovdl::detail::to_underlying(ov_asm_type));

				inst_store_ov_asm_type(arguments, 0, ovdl::detail::to_underlying(ov_asm_type));
			}

			// Load arguments address (vstack[2])
			lauf_asm_inst_local_addr(*this, arguments);
			// Load scope address in lauf (vstack[1])
			push_instruction_for_scope(scope_execution_type::Effect, current_scope.type, current_scope.symbol);
			// Create effect name literal (vstack[0])
			auto effect_name = lauf_asm_build_string_literal(*this, left->value().c_str());
			lauf_asm_inst_global_addr(*this, effect_name);
			// Consumes vstack[0], vstack[1], and vstack[2]
			lauf_asm_inst_call_builtin(*this, call_effect);

			if (is_iterative) {
				// TODO: loop footer
			}
		},
		[&](const FlatValue* value) {
			using enum Asm::argument::type_t;
			if (!is_arguments) {
				return;
			}

			if (push_instruction_for_scope(scope_execution_type::Effect, current_scope.type, value->value())) {
				ov_asm_type = scope;
				return;
			}

			auto view = value->value().view();
			if (view[0] == '-') {
				if (std::int64_t value; std::from_chars(view.begin(), view.end(), value).ptr == view.end()) {
					lauf_asm_inst_sint(*this, value);
					ov_asm_type = int_;
					return;
				}
			}

			if (std::uint64_t value; std::from_chars(view.begin(), view.end(), value).ptr == view.end()) {
				lauf_asm_inst_uint(*this, value);
				ov_asm_type = uint;
				return;
			}

			{
				bool success;
				auto value = fixed_point_t::parse(view, &success);
				if (success) {
					lauf_asm_inst_sint(*this, value.get_raw_value());
					ov_asm_type = fixed_point;
					return;
				}
			}

			// Create argument string literal
			auto argument_str =
				lauf_asm_build_data_literal(*this, reinterpret_cast<const unsigned char*>(view.data()), view.size());
			lauf_asm_inst_global_addr(*this, argument_str);
			ov_asm_type = cstring;
		},
		[&](dryad::child_visitor<NodeKind> visitor, const ListValue* value) {
			if (!is_arguments) {
				visitor(value);
				return;
			}

			auto limit_function = create_condition_function(current_scope.type, value);
			lauf_asm_inst_function_addr(*this, limit_function);
			ov_asm_type = Asm::argument::type_t::function_address;
		}
	);
}

void Codegen::generate_condition_from(scope_type type, const Node* node) {
	struct current_scope_t {
		scope_type type;
		ovdl::symbol<char> symbol;
	} current_scope { .type = type, .symbol = {} };

	bool is_prepping_args = false;
	tsl::ordered_map<std::string_view, std::string_view> prepped_arguments;

	dryad::visit_tree(
		node, //
		[&](dryad::child_visitor<NodeKind> visitor, AssignStatement* statement) {
			auto const* left = dryad::node_try_cast<FlatValue>(statement->left());
			if (!left) {
				return;
			}

			auto const* right = dryad::node_try_cast<FlatValue>(statement->right());
			if (!right) {
				using enum Codegen::scope_execution_type;
				bool is_iterative = is_iterative_scope(Trigger, current_scope.type, current_scope.symbol);
				if (is_iterative) {}
				is_prepping_args = current_scope.type >> get_scope_type_for(Trigger, current_scope.symbol);
				visitor(right);
				if (is_iterative) {}
			} else if (auto yes_symbol = _parser.find_intern("yes"sv); yes_symbol && right->value() == yes_symbol) {
				// TODO: insert vic2 bytecode scope object address here
				// TODO: calls a builtin for Victoria 2 triggers?
			} else if (_parser.find_intern("no"sv) != right->value()) {
				// TODO: single argument execution
			}
		},
		[&](FlatValue* value) {
			// TODO: handle right side
		}
	);
}

bool Codegen::push_instruction_for_scope(
	scope_execution_type execution_type, scope_type type, ovdl::symbol<char> scope_symbol
) {
	if (type >> get_scope_type_for(execution_type, scope_symbol)) {
		if (auto static_scope = get_static_scope(execution_type, type, scope_symbol);
			!std::holds_alternative<std::monostate>(static_scope)) {
			lauf_asm_inst_uint(*this, _scope_definitions.size());
			_scope_definitions.push_back(std::move(static_scope));
			lauf_asm_inst_call_builtin(*this, load_static_scope_ptr);
			return true;
		}

#define SCOPE_LIST(END) \
	X(from) \
	X(this) \
	X(year) \
	X(month) \
	X(has_global_flag) \
	X(is_canal_enabled) \
	END

#define X(SCOPE_NAME) _parser.find_intern(#SCOPE_NAME##sv) == scope_symbol ||

		if (SCOPE_LIST(false)) {
			lauf_asm_inst_null(*this);
		} else {
			lauf_asm_inst_call_builtin(*this, load_current_scope);
		}

#undef X
#undef SCOPE_LIST

		auto scope_str = lauf_asm_build_string_literal(*this, scope_symbol.c_str());
		lauf_asm_inst_global_addr(*this, scope_str);
		lauf_asm_inst_call_builtin(*this, load_relative_scope_ptr);
		return true;
	}

	return false;
}

static constexpr lauf_asm_layout ov_asm_argument_layout[] = { LAUF_ASM_NATIVE_LAYOUT_OF(OpenVic::Asm::argument::key),
															  LAUF_ASM_NATIVE_LAYOUT_OF(OpenVic::Asm::argument::type),
															  LAUF_ASM_NATIVE_LAYOUT_OF(OpenVic::Asm::argument::value) };

bool Codegen::inst_store_ov_asm_key_null(lauf_asm_local* local, std::size_t index) {
	lauf_asm_inst_null(*this);
	// Start Load arguments //
	// vstack[1]
	lauf_asm_inst_local_addr(*this, local);
	// vstack[0]
	lauf_asm_inst_uint(*this, index);
	// Consumes vstack[0] = arguments_index, vstack[1] = argument_key_address, produces array address as
	// vstack[0]
	lauf_asm_inst_array_element(*this, lauf_asm_type_value.layout);
	// End Load arguments //
	lauf_asm_inst_aggregate_member(*this, 0, ov_asm_argument_layout, 3);
	// Consumes vstack[0] and vstack[1]
	lauf_asm_inst_store_field(*this, lauf_asm_type_value, 0);
	return true;
}

bool Codegen::inst_store_ov_asm_key(lauf_asm_local* local, std::size_t index, ovdl::symbol<char> key) {
	// Create key literal
	auto argument_key = lauf_asm_build_string_literal(*this, key.c_str());
	lauf_asm_inst_global_addr(*this, argument_key);
	// Translate key literal to cstring
	lauf_asm_inst_call_builtin(*this, translate_address_to_string);
	// Start Load arguments //
	// vstack[1]
	lauf_asm_inst_local_addr(*this, local);
	// vstack[0]
	lauf_asm_inst_uint(*this, index);
	// Consumes vstack[0] = arguments_index, vstack[1] = argument_key_address, produces array address as
	// vstack[0]
	lauf_asm_inst_array_element(*this, lauf_asm_type_value.layout);
	// End Load arguments //
	lauf_asm_inst_aggregate_member(*this, 0, ov_asm_argument_layout, 3);
	// Consumes vstack[0] and vstack[1]
	lauf_asm_inst_store_field(*this, lauf_asm_type_value, 0);
	return true;
}

bool Codegen::inst_store_ov_asm_value_from_vstack(lauf_asm_local* local, std::size_t index, std::uint8_t type) {
	switch (ovdl::detail::from_underlying<Asm::argument::type_t>(type)) {
		using enum Asm::argument::type_t;
	case cstring:
		// Translate key literal to cstring
		lauf_asm_inst_call_builtin(*this, translate_address_to_string);
		break;
	case ptr:
		// Translate address to pointer
		lauf_asm_inst_call_builtin(*this, translate_address_to_pointer);
		break;
	case scope:
		// Scope pointer is already native
	case function_address:
	case uint:
	case int_:
	case fixed_point:
		// needs no translation
		break;
	}

	// Start Load arguments //
	// vstack[1]
	lauf_asm_inst_local_addr(*this, local);
	// vstack[0]
	lauf_asm_inst_uint(*this, index);
	// Consumes vstack[0] = arguments_index, vstack[1] = argument_key_address, produces array address as
	// vstack[0]
	lauf_asm_inst_array_element(*this, lauf_asm_type_value.layout);
	// End Load arguments //
	lauf_asm_inst_aggregate_member(*this, 2, ov_asm_argument_layout, 3);
	// Consumes vstack[0] and vstack[1]
	lauf_asm_inst_store_field(*this, lauf_asm_type_value, 0);
	return true;
}

bool Codegen::inst_store_ov_asm_type(lauf_asm_local* local, std::size_t index, std::uint8_t type) {
	lauf_asm_inst_uint(*this, static_cast<lauf_uint>(type));
	// Start Load arguments //
	// vstack[1]
	lauf_asm_inst_local_addr(*this, local);
	// vstack[0]
	lauf_asm_inst_uint(*this, index);
	// Consumes vstack[0] = arguments_index, vstack[1] = argument_key_address, produces array address as
	// vstack[0]
	lauf_asm_inst_array_element(*this, lauf_asm_type_value.layout);
	// End Load arguments //
	lauf_asm_inst_aggregate_member(*this, 1, ov_asm_argument_layout, 3);
	// Consumes vstack[0] and vstack[1]
	lauf_asm_inst_store_field(*this, lauf_asm_type_value, 0);
	return true;
}