#include "ParseHandler.hpp"

#include <algorithm>
#include <cstddef>
#include <cstdlib>
#include <string_view>
#include <type_traits>

#include <openvic-dataloader/detail/Encoding.hpp>

using namespace ovdl::detail;

#ifdef _WIN32
#include <array>
#include <cstdint>
#include <utility>

#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#undef WIN32_LEAN_AND_MEAN
#endif

template<size_t N>
struct LangCodeLiteral {
	char value[N];

	constexpr LangCodeLiteral(const char (&str)[N]) {
		std::copy_n(str, N, value);
	}

	static constexpr std::integral_constant<std::size_t, N - 1> size = {};

	constexpr const char& operator[](std::size_t index) const noexcept {
		return value[index];
	}

	constexpr operator std::string_view() const noexcept {
		return std::string_view(value, size());
	}

	constexpr bool operator==(const std::string_view view) const noexcept {
		return view.size() >= size() + 1 && view.starts_with(*this) && view[size()] == '_';
	}
};

struct LangCodeView {
	std::string_view view;
	bool is_valid;

	constexpr LangCodeView() = default;

	template<std::size_t N>
	constexpr LangCodeView(const char (&str)[N]) : view(str), is_valid(true) {}

	constexpr LangCodeView(char* str) : view(str) {
		is_valid = view.find('_') != std::string_view::npos;
	}

	constexpr std::size_t size() const noexcept {
		return view.size();
	}

	constexpr const char& operator[](std::size_t index) const noexcept {
		return view[index];
	}

	constexpr operator std::string_view() const noexcept {
		return view;
	}

	template<std::size_t N>
	constexpr bool operator==(const LangCodeLiteral<N>& literal) {
		return is_valid && size() >= LangCodeLiteral<N>::size() && view.starts_with(literal);
	}
};

struct FallbackSetter {
	std::optional<Encoding>& fallback;

	template<Encoding _Encoding, LangCodeLiteral LangCode>
	constexpr bool encoded(auto&& view) const {
		if (view == LangCode) {
			fallback = _Encoding;
			return true;
		}
		return false;
	};
};

void ParseHandler::_detect_system_fallback_encoding() {
	_system_fallback_encoding = Encoding::Unknown;
	LangCodeView lang_code;

#ifdef _WIN32
	using namespace std::string_view_literals;

	// Every Windows language id mapped to a language code according to https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-lcid/63d3d639-7fd2-4afb-abbe-0d5b5551eef8
	constexpr std::array lang_id_to_lang_code = std::to_array<std::pair<std::uint8_t, LangCodeView>>({
		{ 0x0001, "ar" },
		{ 0x0002, "bg" },
		{ 0x0003, "ca" },
		{ 0x0004, "zh" },
		{ 0x0005, "cs" },
		{ 0x0006, "da" },
		{ 0x0007, "de" },
		{ 0x0008, "el" },
		{ 0x0009, "en" },
		{ 0x000A, "es" },
		{ 0x000B, "fi" },
		{ 0x000C, "fr" },
		{ 0x000D, "he" },
		{ 0x000E, "hu" },
		{ 0x000F, "is" },
		{ 0x0010, "it" },
		{ 0x0011, "ja" },
		{ 0x0012, "ko" },
		{ 0x0013, "nl" },
		{ 0x0014, "no" },
		{ 0x0015, "pl" },
		{ 0x0016, "pt" },
		{ 0x0017, "rm" },
		{ 0x0018, "ro" },
		{ 0x0019, "ru" },
		{ 0x001A, "hr" },
		{ 0x001B, "sk" },
		{ 0x001C, "sq" },
		{ 0x001D, "sv" },
		{ 0x001E, "th" },
		{ 0x001F, "tr" },
		{ 0x0020, "ur" },
		{ 0x0021, "id" },
		{ 0x0022, "uk" },
		{ 0x0023, "be" },
		{ 0x0024, "sl" },
		{ 0x0025, "et" },
		{ 0x0026, "lv" },
		{ 0x0027, "lt" },
		{ 0x0028, "tg" },
		{ 0x0029, "fa" },
		{ 0x002A, "vi" },
		{ 0x002B, "hy" },
		{ 0x002C, "az" },
		{ 0x002D, "eu" },
		{ 0x002E, "hsb" },
		{ 0x002F, "mk" },
		{ 0x0030, "st" },
		{ 0x0031, "ts" },
		{ 0x0032, "tn" },
		{ 0x0033, "ve" },
		{ 0x0034, "xh" },
		{ 0x0035, "zu" },
		{ 0x0036, "af" },
		{ 0x0037, "ka" },
		{ 0x0038, "fo" },
		{ 0x0039, "hi" },
		{ 0x003A, "mt" },
		{ 0x003B, "se" },
		{ 0x003C, "ga" },
		{ 0x003D, "yi" },
		{ 0x003E, "ms" },
		{ 0x003F, "kk" },
		{ 0x0040, "ky" },
		{ 0x0041, "sw" },
		{ 0x0042, "tk" },
		{ 0x0043, "uz" },
		{ 0x0044, "tt" },
		{ 0x0045, "bn" },
		{ 0x0046, "pa" },
		{ 0x0047, "gu" },
		{ 0x0048, "or" },
		{ 0x0049, "ta" },
		{ 0x004A, "te" },
		{ 0x004B, "kn" },
		{ 0x004C, "ml" },
		{ 0x004D, "as" },
		{ 0x004E, "mr" },
		{ 0x004F, "sa" },
		{ 0x0050, "mn" },
		{ 0x0051, "bo" },
		{ 0x0052, "cy" },
		{ 0x0053, "km" },
		{ 0x0054, "lo" },
		{ 0x0055, "my" },
		{ 0x0056, "gl" },
		{ 0x0057, "kok" },
		{ 0x0058, "mni" },
		{ 0x0059, "sd" },
		{ 0x005A, "syr" },
		{ 0x005B, "si" },
		{ 0x005C, "chr" },
		{ 0x005D, "iu" },
		{ 0x005E, "am" },
		{ 0x005F, "tzm" },
		{ 0x0060, "ks" },
		{ 0x0061, "ne" },
		{ 0x0062, "fy" },
		{ 0x0063, "ps" },
		{ 0x0064, "fil" },
		{ 0x0065, "dv" },
		{ 0x0066, "bin" },
		{ 0x0067, "ff" },
		{ 0x0068, "ha" },
		{ 0x0069, "ibb" },
		{ 0x006A, "yo" },
		{ 0x006B, "quz" },
		{ 0x006C, "nso" },
		{ 0x006D, "ba" },
		{ 0x006E, "lb" },
		{ 0x006F, "kl" },
		{ 0x0070, "ig" },
		{ 0x0071, "kr" },
		{ 0x0072, "om" },
		{ 0x0073, "ti" },
		{ 0x0074, "gn" },
		{ 0x0075, "haw" },
		{ 0x0076, "la" },
		{ 0x0077, "so" },
		{ 0x0078, "ii" },
		{ 0x0079, "pap" },
		{ 0x007A, "arn" },
		{ 0x007C, "moh" },
		{ 0x007E, "br" },
		{ 0x0080, "ug" },
		{ 0x0081, "mi" },
		{ 0x0082, "oc" },
		{ 0x0083, "co" },
		{ 0x0084, "gsw" },
		{ 0x0085, "sah" },
		{ 0x0086, "qut" },
		{ 0x0087, "rw" },
		{ 0x0088, "wo" },
		{ 0x008C, "prs" },
		{ 0x0091, "gd" },
		{ 0x0092, "ku" },
		{ 0x0093, "quc" } //
	});

#pragma pack(push, 1)
	struct LocaleStruct {
		struct {
			uint8_t language_id;
			uint8_t country_id;
		} language_country;
		uint8_t sort_id : 4;
		uint16_t reserved : 12;
	};
#pragma pack(pop)

	std::uint32_t locale_int = GetSystemDefaultLCID();
	LocaleStruct locale_id;
	std::memcpy(&locale_id, &locale_int, sizeof(locale_id));
	// first 16 bytes are language-country id, next 4 are sort id, last 12 bytes are reserved
	// first 8 are the language id, last 8 bytes are a country id
	const std::uint8_t& lang_id = locale_id.language_country.language_id;

	for (const auto& map : lang_id_to_lang_code) {
		if (map.first != lang_id) continue;
		lang_code = map.second;
		break;
	}
#else
	lang_code = std::getenv("LANG");
#endif

	constexpr FallbackSetter setter { _system_fallback_encoding };

	if (lang_code.size() < 2) {
		_system_fallback_encoding = Encoding::Unknown;
		return;
	}

#define WIN1251(LANG_CODE) \
	if (setter.encoded<Encoding::Windows1251, #LANG_CODE>(lang_code)) return;

#define WIN1252(LANG_CODE) \
	if (setter.encoded<Encoding::Windows1252, #LANG_CODE>(lang_code)) return;

	// More common, prefer
	WIN1252(en);
	WIN1252(es);
	WIN1252(fr);
	WIN1252(de);

	WIN1251(ru);

	WIN1252(af);
	WIN1252(sq);
	WIN1252(eu);
	WIN1252(br);
	WIN1252(co);
	WIN1252(fo);
	WIN1252(gl);
	WIN1252(is);
	WIN1252(io);
	WIN1252(ga);
	WIN1252(id);
	WIN1252(in);
	WIN1252(it);
	WIN1252(lb);
	WIN1252(ms);
	WIN1252(gv);
	WIN1252(no);
	WIN1252(oc);
	WIN1252(pt);
	WIN1252(gd);
	WIN1252(sw);
	WIN1252(fi);
	WIN1252(da);
	WIN1252(et);
	WIN1252(tn);
	WIN1252(ca);
	WIN1252(rm);
	WIN1252(nl);
	WIN1252(sl);
	WIN1252(cy);
	WIN1252(hu);

	WIN1251(be);
	WIN1251(uk);
	WIN1251(bg);
	WIN1251(kk);
	WIN1251(tg);
	WIN1251(sr);
	WIN1251(ky);
	WIN1251(mn);
	WIN1251(mk);
	WIN1251(mo);

	if (lang_code.size() < 3) {
		return;
	}

	WIN1251(mol);

	WIN1252(ast);
	WIN1252(jbo);
	WIN1252(gla);
	WIN1252(sco);
	WIN1252(sma);
	WIN1252(roo);
	WIN1252(swa);
	WIN1252(tsn);
	WIN1252(tok);

#undef WIN1251
#undef WIN1252
}