#include "helpers.h"

#include <algorithm>
#include <array>
#include <cctype>
#include <cstdarg>
#include <cstdio>
#include <cstring>
#include <cwctype>

#include "nlohmann/json.hpp"

RuntimeConfig g_Runtime;

namespace {

std::mutex g_il2cpp_mutex;
std::unordered_map<uintptr_t, void*> g_il2cpp_slots;

void* g_il2cpp_domain_cached = nullptr;
void* (*g_il2cpp_domain_get_fn)() = nullptr;
void* (*g_il2cpp_thread_attach_fn)(void*) = nullptr;
void* (*g_il2cpp_thread_current_fn)() = nullptr;
void (*g_il2cpp_thread_detach_fn)(void*) = nullptr;

thread_local void* g_tls_il2cpp_thread = nullptr;
thread_local bool g_tls_il2cpp_attached_by_us = false;
thread_local bool g_tls_game_thread_context = false;

std::mutex g_i18n_mutex;
bool g_i18n_initialized = false;
std::unordered_map<std::string, std::string> g_en;
std::unordered_map<std::string, std::string> g_zh_cn;

constexpr const char* kI18nBlob = R"json(
{
  "NoClip": {"en":"NoClip", "zh_cn":"NoClip"},
  "FreeCam": {"en":"FreeCam", "zh_cn":"????"},
  "Free Camera": {"en":"Free Camera", "zh_cn":"????"},
  "Fps Unlocker": {"en":"Fps Unlocker", "zh_cn":"????"},
  "FPSModule": {"en":"FPSModule", "zh_cn":"FPS??"},
  "SetDither": {"en":"SetDither", "zh_cn":"????"},
  "Set Dither": {"en":"Set Dither", "zh_cn":"????"},
  "PlayerProfile": {"en":"PlayerProfile", "zh_cn":"????"},
  "Vacuum": {"en":"Vacuum", "zh_cn":"??"},
  "SkillHack": {"en":"SkillHack", "zh_cn":"????"},
  "Free Skill": {"en":"Free Skill", "zh_cn":"????"},
  "ESPModule": {"en":"ESPModule", "zh_cn":"ESP??"},
  "ESP Features": {"en":"ESP Features", "zh_cn":"ESP??"},
  "Prevent Screenshot": {"en":"Prevent Screenshot", "zh_cn":"???"},
  "Unity Explorer": {"en":"Unity Explorer", "zh_cn":"Unity???"},
  "Unity Explorer Window": {"en":"Unity Explorer Window", "zh_cn":"Unity?????"},
  "ON / OFF": {"en":"ON / OFF", "zh_cn":"? / ?"},
  "Move Speed": {"en":"Move Speed", "zh_cn":"????"},
  "Look Sensitivity": {"en":"Look Sensitivity", "zh_cn":"?????"},
  "Roll Speed": {"en":"Roll Speed", "zh_cn":"????"},
  "FOV Speed": {"en":"FOV Speed", "zh_cn":"????"},
  "FOV": {"en":"FOV", "zh_cn":"??"},
  "Fps Value": {"en":"Fps Value", "zh_cn":"???"},
  "UID text": {"en":"UID text", "zh_cn":"UID??"},
  "Name text": {"en":"Name text", "zh_cn":"????"},
  "Name changer": {"en":"Name changer", "zh_cn":"??"},
  "Monster": {"en":"Monster", "zh_cn":"??"},
  "Show Monsters": {"en":"Show Monsters", "zh_cn":"????"},
  "Show NPC": {"en":"Show NPC", "zh_cn":"??NPC"},
  "Show Friendly": {"en":"Show Friendly", "zh_cn":"????"},
  "Show Puzzles": {"en":"Show Puzzles", "zh_cn":"??????"},
  "Show All": {"en":"Show All", "zh_cn":"????"},
  "Show Distance": {"en":"Show Distance", "zh_cn":"????"},
  "Show Name": {"en":"Show Name", "zh_cn":"????"},
  "Show Type": {"en":"Show Type", "zh_cn":"????"},
  "Theme": {"en":"Theme", "zh_cn":"??"},
  "Toggle Console": {"en":"Toggle Console", "zh_cn":"?????"},
  "About": {"en":"About", "zh_cn":"??"},
  "Player": {"en":"Player", "zh_cn":"??"},
  "ESP": {"en":"ESP", "zh_cn":"ESP"},
  "World": {"en":"World", "zh_cn":"??"},
  "Visual": {"en":"Visual", "zh_cn":"??"},
  "Settings": {"en":"Settings", "zh_cn":"??"},
  "Damagehack Toggle": {"en":"Damagehack Toggle", "zh_cn":"????"},
  "Damage Multiplier": {"en":"Damage Multiplier", "zh_cn":"????"},
  "Multiplier Value": {"en":"Multiplier Value", "zh_cn":"???"},
  "Random Damage Type": {"en":"Random Damage Type", "zh_cn":"??????"},
  "This is free, if you spend money, then you have been deceived": {
    "en":"This is free, if you spend money, then you have been deceived",
    "zh_cn":"?????,??????,?????"
  }
}
)json";

ImVec4 ParseHexColor(const char* rrggbbaa) {
    unsigned int rgba = 0u;
    sscanf_s(rrggbbaa, "%x", &rgba);
    const float r = static_cast<float>((rgba >> 24) & 0xFF) / 255.0f;
    const float g = static_cast<float>((rgba >> 16) & 0xFF) / 255.0f;
    const float b = static_cast<float>((rgba >> 8) & 0xFF) / 255.0f;
    const float a = static_cast<float>(rgba & 0xFF) / 255.0f;
    return ImVec4(r, g, b, a);
}

void ApplyThemePalette(const std::array<const char*, 11>& colors) {
    ImGuiStyle& style = ImGui::GetStyle();
    style.Colors[ImGuiCol_Text] = ParseHexColor(colors[0]);
    style.Colors[ImGuiCol_WindowBg] = ParseHexColor(colors[1]);
    style.Colors[ImGuiCol_ChildBg] = ParseHexColor(colors[2]);
    style.Colors[ImGuiCol_PopupBg] = ParseHexColor(colors[3]);
    style.Colors[ImGuiCol_Border] = ParseHexColor(colors[4]);
    style.Colors[ImGuiCol_FrameBg] = ParseHexColor(colors[5]);
    style.Colors[ImGuiCol_FrameBgHovered] = ParseHexColor(colors[6]);
    style.Colors[ImGuiCol_FrameBgActive] = ParseHexColor(colors[7]);
    style.Colors[ImGuiCol_Button] = ParseHexColor(colors[8]);
    style.Colors[ImGuiCol_ButtonHovered] = ParseHexColor(colors[9]);
    style.Colors[ImGuiCol_ButtonActive] = ParseHexColor(colors[10]);
}

uintptr_t FindGameAssemblyBaseNow() {
    HMODULE h = GetModuleHandleW(L"GameAssembly.dll");
    if (!h) {
        h = GetModuleHandleW(L"gameassembly.dll");
    }
    if (h) {
        return reinterpret_cast<uintptr_t>(h);
    }

    HMODULE modules[2048] = {};
    DWORD needed = 0;
    if (!K32EnumProcessModules(GetCurrentProcess(), modules, sizeof(modules), &needed)) {
        return 0;
    }

    const size_t count = needed / sizeof(HMODULE);
    for (size_t i = 0; i < count; ++i) {
        wchar_t path[MAX_PATH] = {};
        if (K32GetModuleFileNameExW(GetCurrentProcess(), modules[i], path, MAX_PATH) == 0) {
            continue;
        }
        std::wstring name = path;
        std::transform(name.begin(), name.end(), name.begin(), [](wchar_t c) {
            return static_cast<wchar_t>(::towlower(c));
        });
        if (name.find(L"gameassembly.dll") != std::wstring::npos) {
            return reinterpret_cast<uintptr_t>(modules[i]);
        }
    }
    return 0;
}

void ResolveIl2CppThreadApisOnce() {
    HMODULE ga = GetModuleHandleW(L"GameAssembly.dll");
    if (!ga) {
        ga = GetModuleHandleW(L"gameassembly.dll");
    }
    if (!ga) {
        return;
    }

    g_il2cpp_domain_get_fn =
        reinterpret_cast<void* (*)()>(GetProcAddress(ga, "il2cpp_domain_get"));
    g_il2cpp_thread_attach_fn =
        reinterpret_cast<void* (*)(void*)>(GetProcAddress(ga, "il2cpp_thread_attach"));
    g_il2cpp_thread_current_fn =
        reinterpret_cast<void* (*)()>(GetProcAddress(ga, "il2cpp_thread_current"));
    g_il2cpp_thread_detach_fn =
        reinterpret_cast<void (*)(void*)>(GetProcAddress(ga, "il2cpp_thread_detach"));
}

}  // namespace

const std::array<Il2cppSlotDefinition, 71> kIl2cppSlotMap = {{
    {0x1C48, 0x09DC0120, "GameObject.GetComponentByIndex"},
    {0x1C50, 0x0018CEC0, "il2cpp_domain_get_assemblies_A"},
    {0x1C58, 0x0B390700, "Component.GetComponent<Transform>"},
    {0x1C60, 0x0B3A2D20, "Transform.get_localScale"},
    {0x1C68, 0x0B3A2CB0, "Transform.get_rotation"},
    {0x1C70, 0x0018AD80, "il2cpp_object_get_class"},
    {0x1C78, 0x00007480, "il2cpp_class_get_method_from_name"},
    {0x1C80, 0x0B3A1AE0, "Transform.get_localPosition"},
    {0x1C88, 0x0B3A1A70, "Transform.get_position"},
    {0x1C90, 0x0B3A51D0, "Transform.set_localPosition"},
    {0x1C98, 0x0B398830, "GameObject.SetActive"},
    {0x1CA0, 0x0B3911F0, "GameObject.get_transform"},
    {0x1CA8, 0x0B3A59D0, "Transform.set_rotation"},
    {0x1CB0, 0x0B391D90, "GameObject.get_activeInHierarchy"},
    {0x1CB8, 0x0B3B2410, "GameObject.get_tag"},
    {0x1CC0, 0x0B3B2120, "GameObject.get_name"},
    {0x1CC8, 0x0B3B40B0, "GameObject.get_layer"},
    {0x1CD0, 0x0B397980, "GameObject.get_scene"},
    {0x1CD8, 0x02F3DA80, "Game_SkillBuff_A"},
    {0x1CE0, 0x00F27E10, "GetEntityName"},
    {0x1CE8, 0x0B329000, "Component.GetComponents"},
    {0x1CF0, 0x0B329D80, "Component.GetComponentsInChildren"},
    {0x1CF8, 0x03E9BB50, "Game_SkillSlot_A"},
    {0x1D00, 0x0B383F60, "Object.get_name"},
    {0x1D08, 0x0B33CAB0, "Component.GetType_A"},
    {0x1D10, 0x0B33CB00, "Component.GetType_B"},
    {0x1D18, 0x039D1AA0, "Game_SkillSlot_B"},
    {0x1D20, 0x026DE9F0, "Game_Combat_HitA"},
    {0x1D28, 0x0478E860, "GetEntityManager"},
    {0x1D30, 0x025E2D40, "Game_Combat_HitB"},
    {0x1D38, 0x087C2CD0, "Game_Movement_PhysA"},
    {0x1D40, 0x03419AF0, "Game_Movement_PhysB"},
    {0x1D48, 0x0B322FB0, "Scene.get_name / Application.set_targetFrameRate ref"},
    {0x1D50, 0x0B396A20, "SceneManager.GetActiveScene"},
    {0x1D58, 0x0B397700, "CinemachineBrain.get_ActiveVirtualCamera"},
    {0x1D60, 0x03766810, "Game_EntityState_A"},
    {0x1D68, 0x0B3A2A60, "Transform.set_localScale"},
    {0x1D70, 0x0B326660, "Rigidbody.get_velocity"},
    {0x1D78, 0x0B3266B0, "Rigidbody.set_velocity"},
    {0x1D80, 0x0B383200, "Object.Destroy"},
    {0x1D88, 0x0B3A1A10, "Transform.set_position"},
    {0x1D90, 0x0B3A2340, "Game_EntityState_B"},
    {0x1D98, 0x0B421800, "Input.GetAxis(Mouse X)"},
    {0x1DA0, 0x0B3A26D0, "Game_PlayerState_A"},
    {0x1DA8, 0x0B3A1FB0, "Game_PlayerState_B"},
    {0x1DB0, 0x0B32B030, "Game_PlayerHealthStat"},
    {0x1DB8, 0x0B391240, "GameObject.SetActive (second ref)"},
    {0x1DC0, 0x0B390440, "Camera.get_main"},
    {0x1DC8, 0x0B390F80, "GameObject.FindObjectOfType"},
    {0x1DD0, 0x0B3A19A0, "Transform.get_position (second ref)"},
    {0x1DD8, 0x03F85430, "Game_SkillAction_C"},
    {0x1DE0, 0x0B3A1D30, "Transform.set_rotation (second ref)"},
    {0x1DE8, 0x0B3A1C90, "Camera.get_fieldOfView"},
    {0x1DF0, 0x00E92CF0, "Game_EntityState_C"},
    {0x1E00, 0x03DC14C0, "Game_SkillAction_D"},
    {0x1E08, 0x03E0D2C0, "Game_SkillAction_E"},
    {0x1E10, 0x03D9DF30, "Game_SkillAction_F"},
    {0x1E18, 0x00E9E9F0, "Game_SkillAction_G"},
    {0x1E20, 0x03EA53C0, "Game_SkillAction_H"},
    {0x1E28, 0x0ACA0EC0, "TMPro.set_text"},
    {0x1E30, 0x0B391D40, "UnityUI.Text.set_text"},
    {0x1E38, 0x036AA8F0, "Game_SkillAction_I"},
    {0x1E40, 0x03EC31C0, "Game_SkillAction_J"},
    {0x1E48, 0x037F8CD0, "Game_EntityActor_D"},
    {0x1E50, 0x036EA640, "Game_SkillAction_K"},
    {0x1E58, 0x03EC30E0, "Game_SkillAction_L"},
    {0x1E60, 0x037F2A40, "Game_EntityActor_E"},
    {0x1E68, 0x037FD7E0, "Game_EntityActor_F"},
    {0x1E70, 0x00D94C10, "il2cpp_domain_get"},
    {0x1E78, 0x00D94DA0, "il2cpp_assembly_get_image"},
    {0x1E80, 0x00D93A60, "il2cpp_domain_get_assemblies_B"},
}};

void Log(const char* fmt, ...) {
    char buffer[2048] = {};
    va_list args;
    va_start(args, fmt);
    std::vsnprintf(buffer, sizeof(buffer), fmt, args);
    va_end(args);

    OutputDebugStringA(buffer);
    OutputDebugStringA("\n");

    HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
    if (h != nullptr && h != INVALID_HANDLE_VALUE) {
        DWORD written = 0;
        WriteConsoleA(h, buffer, static_cast<DWORD>(std::strlen(buffer)), &written, nullptr);
        WriteConsoleA(h, "\n", 1, &written, nullptr);
    }
}

std::wstring Utf8ToWide(const std::string& value) {
    if (value.empty()) {
        return {};
    }
    const int size = MultiByteToWideChar(65001, 0, value.c_str(), -1, nullptr, 0);
    if (size <= 0) {
        return {};
    }
    std::wstring result(static_cast<size_t>(size), L'\0');
    MultiByteToWideChar(65001, 0, value.c_str(), -1, result.data(), size);
    if (!result.empty() && result.back() == L'\0') {
        result.pop_back();
    }
    return result;
}

std::string WideToUtf8(const std::wstring& value) {
    if (value.empty()) {
        return {};
    }
    const int size = WideCharToMultiByte(65001, 0, value.c_str(), -1, nullptr, 0, nullptr, nullptr);
    if (size <= 0) {
        return {};
    }
    std::string result(static_cast<size_t>(size), '\0');
    WideCharToMultiByte(65001, 0, value.c_str(), -1, result.data(), size, nullptr, nullptr);
    if (!result.empty() && result.back() == '\0') {
        result.pop_back();
    }
    return result;
}

uintptr_t GetGameAssemblyBase() {
    if (g_Runtime.game_assembly_base != 0) {
        return g_Runtime.game_assembly_base;
    }
    g_Runtime.game_assembly_base = FindGameAssemblyBaseNow();
    return g_Runtime.game_assembly_base;
}

bool WaitForGameAssembly(uint32_t timeout_ms, uint32_t poll_ms) {
    const ULONGLONG start = GetTickCount64();
    while (g_Runtime.running.load(std::memory_order_relaxed) || timeout_ms == 0) {
        const uintptr_t base = FindGameAssemblyBaseNow();
        if (base != 0) {
            g_Runtime.game_assembly_base = base;
            return true;
        }

        if (timeout_ms != 0) {
            const ULONGLONG elapsed = GetTickCount64() - start;
            if (elapsed >= timeout_ms) {
                break;
            }
        }
        Sleep(poll_ms);
    }
    return false;
}

void ResolveGABypassSlots() {
    std::scoped_lock lock(g_il2cpp_mutex);
    g_il2cpp_slots.clear();

    const uintptr_t base = GetGameAssemblyBase();
    if (base == 0) {
        Log("IL2CPP Domain Not Found!");
        return;
    }

    for (const auto& slot : kIl2cppSlotMap) {
        g_il2cpp_slots[slot.slot_offset] = reinterpret_cast<void*>(base + slot.gameassembly_offset);
    }
    Log("IL2CPP Domain Found: 0x%p", reinterpret_cast<void*>(base));
}

void* GetIl2cppSlot(uintptr_t slot_offset) {
    std::scoped_lock lock(g_il2cpp_mutex);
    const auto it = g_il2cpp_slots.find(slot_offset);
    if (it == g_il2cpp_slots.end()) {
        return nullptr;
    }
    return it->second;
}

bool EnsureIl2CppThreadAttached() {
    if (!g_il2cpp_thread_attach_fn || !g_il2cpp_domain_get_fn) {
        ResolveIl2CppThreadApisOnce();
    }

    if (!g_il2cpp_thread_attach_fn || !g_il2cpp_domain_get_fn) {
        g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed);
        return false;
    }

    void* domain = g_il2cpp_domain_cached;
    if (!domain) {
        domain = g_il2cpp_domain_get_fn();
        g_il2cpp_domain_cached = domain;
    }

    if (!domain) {
        g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed);
        return false;
    }

    if (g_il2cpp_thread_current_fn) {
        void* current = g_il2cpp_thread_current_fn();
        if (current) {
            g_tls_il2cpp_thread = current;
            g_tls_il2cpp_attached_by_us = false;
            g_Runtime.il2cpp_thread_attached.store(true, std::memory_order_relaxed);
            return true;
        }
    } else if (g_tls_il2cpp_thread) {
        g_Runtime.il2cpp_thread_attached.store(true, std::memory_order_relaxed);
        return true;
    }

    void* attached = g_il2cpp_thread_attach_fn(domain);
    if (!attached) {
        g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed);
        return false;
    }

    g_tls_il2cpp_thread = attached;
    g_tls_il2cpp_attached_by_us = true;
    g_Runtime.il2cpp_thread_attached.store(true, std::memory_order_relaxed);
    return true;
}

bool WaitForIl2CppThreadAttach(uint32_t timeout_ms, uint32_t poll_ms) {
    const ULONGLONG start = GetTickCount64();
    for (;;) {
        if (EnsureIl2CppThreadAttached()) {
            return true;
        }
        if (timeout_ms != 0) {
            const ULONGLONG elapsed = GetTickCount64() - start;
            if (elapsed >= timeout_ms) {
                return false;
            }
        }
        Sleep(poll_ms);
    }
}

void DetachIl2CppThreadIfAttached() {
    if (!g_tls_il2cpp_thread || !g_tls_il2cpp_attached_by_us) {
        return;
    }

    if (!g_il2cpp_thread_detach_fn) {
        ResolveIl2CppThreadApisOnce();
    }
    if (g_il2cpp_thread_detach_fn) {
        g_il2cpp_thread_detach_fn(g_tls_il2cpp_thread);
    }

    g_tls_il2cpp_thread = nullptr;
    g_tls_il2cpp_attached_by_us = false;
    g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed);
}

void SetGameThreadContext(bool enabled) {
    g_tls_game_thread_context = enabled;
    if (enabled) {
        const DWORD tid = GetCurrentThreadId();
        DWORD known = g_Runtime.game_thread_id.load(std::memory_order_relaxed);
        if (known == 0) {
            g_Runtime.game_thread_id.store(tid, std::memory_order_relaxed);
        }
    }
}

bool IsGameThreadContext() {
    if (g_tls_game_thread_context) {
        return true;
    }
    const DWORD known = g_Runtime.game_thread_id.load(std::memory_order_relaxed);
    return known != 0 && known == GetCurrentThreadId();
}

bool IsWindowsBuildAtLeast(uint32_t build_number) {
    using RtlGetVersionFn = LONG(WINAPI*)(PRTL_OSVERSIONINFOW);

    static std::atomic<uint32_t> cached_build{0};
    uint32_t value = cached_build.load(std::memory_order_acquire);
    if (value == 0) {
        HMODULE ntdll = GetModuleHandleW(L"ntdll.dll");
        if (!ntdll) {
            ntdll = LoadLibraryW(L"ntdll.dll");
        }
        if (!ntdll) {
            return false;
        }

        auto* rtl_get_version = reinterpret_cast<RtlGetVersionFn>(
            GetProcAddress(ntdll, "RtlGetVersion"));
        if (!rtl_get_version) {
            return false;
        }

        RTL_OSVERSIONINFOW info{};
        info.dwOSVersionInfoSize = sizeof(info);
        if (rtl_get_version(&info) == 0) {
            value = info.dwBuildNumber;
            cached_build.store(value, std::memory_order_release);
        }
    }

    return value >= build_number;
}

void ToggleConsole(bool enabled) {
    if (enabled) {
        if (GetConsoleWindow() == nullptr) {
            AllocConsole();
            FILE* stream = nullptr;
            freopen_s(&stream, "CONOUT$", "w", stdout);
            freopen_s(&stream, "CONOUT$", "w", stderr);
            SetConsoleOutputCP(65001);
            SetConsoleTitleA("il2cpp Game Console");
        }
    } else {
        if (GetConsoleWindow() != nullptr) {
            ShowWindow(GetConsoleWindow(), SW_HIDE);
        }
    }
}

bool ScanLoadedModulesForInjectionMarkers() {
    static const std::wstring kMarkerA = L"testyip";
    static const std::wstring kMarkerB = L"gatmp.tmp";
    static const std::wstring kMarkerC = L"ef-cheeto.dll";

    HMODULE modules[2048] = {};
    DWORD needed = 0;
    if (!K32EnumProcessModules(GetCurrentProcess(), modules, sizeof(modules), &needed)) {
        return false;
    }

    const size_t count = needed / sizeof(HMODULE);
    for (size_t i = 0; i < count; ++i) {
        wchar_t path[MAX_PATH] = {};
        if (K32GetModuleFileNameExW(GetCurrentProcess(), modules[i], path, MAX_PATH) == 0) {
            continue;
        }
        std::wstring lower = path;
        std::transform(lower.begin(), lower.end(), lower.begin(), [](wchar_t c) {
            return static_cast<wchar_t>(::towlower(c));
        });
        if (lower.find(kMarkerA) != std::wstring::npos ||
            lower.find(kMarkerB) != std::wstring::npos ||
            lower.find(kMarkerC) != std::wstring::npos) {
            return true;
        }
    }
    return false;
}

void InitializeI18N() {
    std::scoped_lock lock(g_i18n_mutex);
    if (g_i18n_initialized) {
        return;
    }

    const nlohmann::json parsed = nlohmann::json::parse(kI18nBlob, nullptr, false);
    if (!parsed.is_object()) {
        g_i18n_initialized = true;
        return;
    }

    for (auto it = parsed.begin(); it != parsed.end(); ++it) {
        const std::string key = it.key();
        const nlohmann::json& item = it.value();
        if (!item.is_object()) {
            continue;
        }
        g_en[key] = item.value("en", key);
        g_zh_cn[key] = item.value("zh_cn", key);
    }
    g_i18n_initialized = true;
}

const char* Tr(const char* key) {
    InitializeI18N();

    std::scoped_lock lock(g_i18n_mutex);
    const std::string k = key ? key : "";
    const Language lang = g_Runtime.language.load(std::memory_order_relaxed);

    const auto fallback_it = g_en.find(k);
    if (lang == Language::ZhCN) {
        const auto it = g_zh_cn.find(k);
        if (it != g_zh_cn.end()) {
            return it->second.c_str();
        }
    }

    if (fallback_it != g_en.end()) {
        return fallback_it->second.c_str();
    }
    return key ? key : "";
}

void SetLanguage(Language language) {
    g_Runtime.language.store(language, std::memory_order_relaxed);
}

void ApplyThemeDefault() {
    ImGui::StyleColorsDark();
}

void ApplyThemeEvangelionUnit01() {
    static constexpr std::array<const char*, 11> kColors = {{
        "FFFFFFFF", "7857A7FF", "19171CFF", "2A282EFF", "2A282EE6", "4DE6A5FF",
        "00000000", "4A455240", "A38CCF80", "7857A780", "4A4552FF"}};
    ApplyThemePalette(kColors);
}

void ApplyThemeEvangelionUnit02() {
    static constexpr std::array<const char*, 11> kColors = {{
        "FFFFFFFF", "D9293BFF", "1E1E1EFF", "3A3A3AFF", "3A3A3AE6", "F7B302FF",
        "00000000", "4A455240", "F7465880", "D9293B80", "4A4552FF"}};
    ApplyThemePalette(kColors);
}

void ApplyThemeMatrix() {
    static constexpr std::array<const char*, 11> kColors = {{
        "00FF41FF", "00AA2CFF", "000000FF", "0A0A0AFF", "0A0A0AE6", "004400FF",
        "00000000", "00440040", "00881EFF", "00FF4180", "00FF4180"}};
    ApplyThemePalette(kColors);
}

bool IsKeyPressedOnce(int vk) {
    return (GetAsyncKeyState(vk) & 0x1) != 0;
}