#include <string>
#include <spdlog/spdlog.h>
#include <spdlog/sinks/rotating_file_sink.h>
#include <filesystem>
#include <safetyhook.hpp>
#include "ObfuscateString.h"
#include "Memory.hpp";
#include "Maths.hpp";
#include "UEngine.hpp";
#include "SDK/Basic.hpp"
#include "SDK/Engine_classes.hpp"
#include "SDK/Charlie_classes.hpp"
#include "SDK/UMG_classes.hpp"
#include "HUD_PlayerStatus_SUMG_classes.hpp"

using namespace SDK;

// Constants
const std::string PLUGIN_NAME = "HellIsUs";
const std::string PLUGIN_LOG = PLUGIN_NAME + ".log";
const std::string gameExecutable = "HellIsUs-Win64-Shipping.exe";
const float baseAspect = 1.777777791;
const float DEFAULT_WORLD_FOV = 70.f;
const float DEFAULT_CAMERA_HEIGHT = -15.f;

// Logger
std::shared_ptr<spdlog::logger> logger;

// Screen informations
static int screenWidth = GetSystemMetrics(SM_CXSCREEN);
static int screenHeight = GetSystemMetrics(SM_CYSCREEN);
static float aspectRatio = (float)screenWidth / screenHeight;

// Plugin states
static bool AOBScanDone = false;
static bool g_fix_enabled = false;
static bool g_fov_fix_enabled = false;
static bool g_aspect_fix_enabled = false;
static bool g_DOF_fix_enabled = false;
static bool g_CA_fix_enabled = false;
static bool g_Vignetting_fix_enabled = false;
static bool g_Fog_fix_enabled = false;
static bool g_Camera_fix_enabled = false;
static bool g_HUD_fix_enabled = false;
static int g_AdditionalFOVValue = 0;
static float g_cameraDistanceMultiplier = 1.f;
static float g_cameraHeight = -15.f;

// Shared values
static float g_FOV_In = 0;
static float g_Compensated_FOV = 0;
static float g_FOV_Out = 0;
static bool g_Console_Enabled = false;

// AOB Unreal Engine offsets addresses
static uint8_t* GObjectsaddress = nullptr;
static uint8_t* GNamesaddress = nullptr;
static uint8_t* AppendStringaddress = nullptr;
static uint8_t* ProcessEventaddress = nullptr;

// AOB Scan pointers
static uint8_t* FOVaddress = nullptr;
static uint8_t* Aspectaddress = nullptr;
static uint8_t* DOFaddress = nullptr;
static uint8_t* CAaddress = nullptr;
static uint8_t* Vignettingaddress = nullptr;
static uint8_t* Fogaddress = nullptr;
static uint8_t* Cameraaddress = nullptr;
//static uint8_t* UEConstructaddress = nullptr;
static uint8_t* SetAnchorsaddress = nullptr;

// Hooking
static SafetyHookMid FOVHook{};
static SafetyHookMid AspectHook{};
static SafetyHookMid FogHook{};
static SafetyHookMid CameraHook{};
static SafetyHookMid HUDHook{};

// HUD anchors
static FAnchors HUDAnchors = {{ 0.f, 0.f }, { 0.f , 1.f }};
static FAnchors TradeListAnchors = { { 0.2f, 0.f }, { 0.2f , 1.f } };
static FAnchors defaultHUDAnchors = {{ 0.f, 0.f }, { 1.f, 1.f }}; // Will be displayed on all screen viewport

// Camera Mode
enum class ECharlieCameraMode : uint8_t
{
    Camera = 1,
    FOV = 2
};

// Prototypes
static void FOVFixEnabled(bool fix_enabled);
static void AspectFixEnabled(bool fix_enabled);
static void DOFFixEnabled(bool fix_enabled);
static void CAFixEnabled(bool fix_enabled);
static void VignettingFixEnabled(bool fix_enabled);
static void FogFixEnabled(bool fix_enabled);
static void CameraFixEnabled(bool fix_enabled, ECharlieCameraMode Mode);
static void HUDFixEnabled(bool fix_enabled);
static void EnableConsole();

extern "C" __declspec(dllexport) void SetFixEnabled(bool enabled)
{
    g_fix_enabled = enabled;
    if (g_fix_enabled && !AOBScanDone) {
        logger->info("--------------- AOB scan started ---------------");
        if (FOVaddress == nullptr) {
            constexpr auto FOVStringObfuscated = make_obfuscated<0x4A>("77 ?? 48 ?? ?? FF ?? ?? ?? ?? ?? F3 0F ?? ?? ?? 48");
            FOVaddress = Memory::AOBScan(gameExecutable, FOVStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
            //"HellIsUs-Win64-Shipping.exe" + 3C92144 - 48 8B 01          - mov rax, [rcx]
            //"HellIsUs-Win64-Shipping.exe" + 3C92147 - FF 90 60 07 00 00 - call qword ptr[rax + 00000760]
            //"HellIsUs-Win64-Shipping.exe" + 3C9214D - F3 0F 10 40 30    - movss xmm0, [rax + 30]
            //"HellIsUs-Win64-Shipping.exe" + 3C92152 - 48 83 C4 28       - add rsp, 28
            //"HellIsUs-Win64-Shipping.exe" + 3C92156 - C3                - ret

            if (!FOVaddress)
                logger->warn("FOV signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
            else {
                logger->info("FOV signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(FOVaddress));
                FOVaddress += 0x10;
            }
        }

        if (Aspectaddress == nullptr) {
            constexpr auto AspectStringObfuscated = make_obfuscated<0x4A>("E9 ?? ?? ?? ?? CC CC CC CC CC CC 48 89 ?? ?? ?? 57 48 83 ?? ?? 0F ?? ?? 48 ?? ?? 48");
            Aspectaddress = Memory::AOBScan(gameExecutable, AspectStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
            //"HellIsUs-Win64-Shipping.exe" + 3453EBA - 89 41 58    - mov[rcx + 58], eax
            //"HellIsUs-Win64-Shipping.exe" + 3453EBD - 8B 42 5C    - mov eax, [rdx + 5C]
            //"HellIsUs-Win64-Shipping.exe" + 3453EC0 - 89 41 5C    - mov[rcx + 5C], eax <<= Aspect ratio
            //"HellIsUs-Win64-Shipping.exe" + 3453EC3 - 48 8D 42 60 - lea rax, [rdx + 60]
            //"HellIsUs-Win64-Shipping.exe" + 3453EC7 - 48 83 C1 60 - add rcx, 60

            if (!Aspectaddress)
                logger->warn("Aspect ratio ratio signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
            else {
                logger->info("Aspect ratio signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(Aspectaddress));
                Aspectaddress = Aspectaddress + 0x8b;
            }
        }

        if (DOFaddress == nullptr) {
            constexpr auto DOFStringObfuscated = make_obfuscated<0x4A>("74 ?? 48 ?? ?? 8B ?? ?? 48 ?? ?? E8");
            DOFaddress = Memory::AOBScan(gameExecutable, DOFStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
            //"HellIsUs-Win64-Shipping.exe" + 26ABA27 - 74 03           - je "HellIsUs-Win64-Shipping.exe" + 26ABA2C
            //"HellIsUs-Win64-Shipping.exe" + 26ABA29 - 48 8B C3        - mov rax, rbx
            //"HellIsUs-Win64-Shipping.exe" + 26ABA2C - 8B 34 30        - mov esi, [rax + rsi]
            //"HellIsUs-Win64-Shipping.exe" + 26ABA2F - 48 8B CF        - mov rcx, rdi
            //"HellIsUs-Win64-Shipping.exe" + 26ABA32 - E8 D9 C4 6C 01  - call "HellIsUs-Win64-Shipping.exe" + 3D77F10

            if (!DOFaddress)
                logger->warn("DOF signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
            else {
                logger->info("DOF signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(DOFaddress));
                DOFaddress += 0x5;
            }
        }

        if (CAaddress == nullptr) {
            constexpr auto CAStringObfuscated = make_obfuscated<0x4A>("7F ?? 44 89 ?? ?? ?? ?? ?? 43 ?? ?? ?? 39 05");
            CAaddress = Memory::AOBScan(gameExecutable, CAStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
            //"HellIsUs-Win64-Shipping.exe" + 3D73BC2 - 48 8B 05 D7 F7 6E 05 - mov rax, ["HellIsUs-Win64-Shipping.exe" + 94633A0]
            //"HellIsUs-Win64-Shipping.exe" + 3D73BC9 - 44 39 38             - cmp[rax], r15d
            //"HellIsUs-Win64-Shipping.exe" + 3D73BCC - 7F 07                - jg "HellIsUs-Win64-Shipping.exe" + 3D73BD5
            //"HellIsUs-Win64-Shipping.exe" + 3D73BCE - 44 89 BB 1C 20 00 00 - mov[rbx + 0000201C], r15d
            //"HellIsUs-Win64-Shipping.exe" + 3D73BD5 - 43 8B 04 26          - mov eax, [r14 + r12]

            if (!CAaddress)
                logger->warn("Chromatic aberrations signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
            else {
                logger->info("Chromatic aberrations signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(CAaddress));
            }
        }

        if (Vignettingaddress == nullptr) {
            constexpr auto VignettingStringObfuscated = make_obfuscated<0x4A>("8B ?? 83 ?? ?? 7D ?? 44 89");
            Vignettingaddress = Memory::AOBScan(gameExecutable, VignettingStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
            //"HellIsUs-Win64-Shipping.exe" + 3D73C64 - 8B 08                - mov ecx, [rax]
            //"HellIsUs-Win64-Shipping.exe" + 3D73C66 - 83 F9 02             - cmp ecx, 02
            //"HellIsUs-Win64-Shipping.exe" + 3D73C69 - 7D 09                - jnl "HellIsUs-Win64-Shipping.exe" + 3D73C74
            //"HellIsUs-Win64-Shipping.exe" + 3D73C6B - 44 89 BB C8 22 00 00 - mov[rbx + 000022C8], r15d
            //"HellIsUs-Win64-Shipping.exe" + 3D73C72 - EB 05                - jmp "HellIsUs-Win64-Shipping.exe" + 3D73C79

            if (!Vignettingaddress)
                logger->warn("Vignetting signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
            else {
                logger->info("Vignetting signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(Vignettingaddress));
                Vignettingaddress += 0x5;
            }
        }

        if (Fogaddress == nullptr) {
            constexpr auto FogStringObfuscated = make_obfuscated<0x4A>("F6 ?? ?? ?? ?? 74 ?? 48 8B ?? ?? ?? ?? ?? 83 78 ?? ?? 75 ?? B3");            
            Fogaddress = Memory::AOBScan(gameExecutable, FogStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
            //"HellIsUs-Win64-Shipping.exe" + 22B77C8 - 74 11                - je "HellIsUs-Win64-Shipping.exe" + 22B77DB
            //"HellIsUs-Win64-Shipping.exe" + 22B77CA - 48 8B 05 8F 23 08 07 - mov rax, ["HellIsUs-Win64-Shipping.exe" + 9339B60]
            //"HellIsUs-Win64-Shipping.exe" + 22B77D1 - 83 78 04 01          - cmp dword ptr[rax + 04], 01
            //"HellIsUs-Win64-Shipping.exe" + 22B77D5 - 75 04                - jne "HellIsUs-Win64-Shipping.exe" + 22B77DB
            //"HellIsUs-Win64-Shipping.exe" + 22B77D7 - B3 01                - mov bl, 01
            //"HellIsUs-Win64-Shipping.exe" + 22B77D9 - EB 02                - jmp "HellIsUs-Win64-Shipping.exe" + 22B77DD
            //"HellIsUs-Win64-Shipping.exe" + 22B77DB - 32 DB                - xor bl, bl

            if (!Fogaddress)
                logger->warn("Fog signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
            else {
                logger->info("Fog signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(Fogaddress));
                Fogaddress += 0x12;
            }            
        }

        if (Cameraaddress == nullptr) {
            constexpr auto FogStringObfuscated = make_obfuscated<0x4A>("28 C3 48 83 ?? ?? 48 8B ?? ?? ?? ?? ?? 48 8B ?? 48 85 ?? 75");
            Cameraaddress = Memory::AOBScan(gameExecutable, FogStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
            //"HellIsUs-Win64-Shipping.exe" + 4E9D3F2 - 48 85 C0       - test rax, rax
            //"HellIsUs-Win64-Shipping.exe" + 4E9D3F5 - 74 0A          - je "HellIsUs-Win64-Shipping.exe" + 4E9D401
            //"HellIsUs-Win64-Shipping.exe" + 4E9D3F7 - F3 0F 10 40 4C - movss xmm0, [rax + 4C]
            //"HellIsUs-Win64-Shipping.exe" + 4E9D3FC - 48 83 C4 28    - add rsp, 28
            //"HellIsUs-Win64-Shipping.exe" + 4E9D400 - C3             - ret

            if (!Cameraaddress)
                logger->warn("Camera signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
            else {
                logger->info("Camera signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(Cameraaddress));
            }
        }

        //4C ?? ?? 55 57 41 ?? 41 ?? 41 ?? 49 8D ?? ?? ?? ?? ?? 48 81 ?? ?? ?? ?? ?? 48 8B ?? ?? ?? ?? ?? 48 ?? ?? 48 89 ?? ?? ?? ?? ?? 83 B9
        // 0x20
        //if (UEConstructaddress == nullptr) {
        //    constexpr auto UEConstructStringObfuscated = make_obfuscated<0x4A>("4C ?? ?? 55 56 57 48 81 ?? ?? ?? ?? ?? 33 ?? 48 C7 ?? ?? ?? ?? ?? 48 ?? ?? 48 ?? ?? 48 C7 ?? ?? ?? ?? ?? ?? 39 B1 ?? ?? ?? ?? 0F 8E ?? ?? ?? ?? 0F B6");
        //    UEConstructaddress = Memory::AOBScan(gameExecutable, UEConstructStringObfuscated.decrypt(), PAGE_EXECUTE_READ);

        //    if (!UEConstructaddress)
        //        logger->warn("UEConstruct signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
        //    else {
        //        logger->info("UEConstruct signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(UEConstructaddress));
        //        //UEConstructaddress += 0x30;
        //    }
        //}

        if (FOVaddress && Aspectaddress && DOFaddress && CAaddress && Vignettingaddress && Fogaddress && Cameraaddress) {
            logger->info("All AOB signatures found. Ready to patch...");
            AOBScanDone = true;
        }

        if (!GObjectsaddress || !AppendStringaddress || !ProcessEventaddress) {
            logger->info("------------ UEngine offsets search ------------");

            constexpr auto GObjetcsStringObfuscated = make_obfuscated<0x4A>("48 8B ?? ?? ?? ?? ?? 48 8B ?? ?? 48 8D ?? ?? EB ?? 33");
            GObjectsaddress = Memory::AOBScan(gameExecutable, GObjetcsStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
            constexpr auto GNamesStringObfuscated = make_obfuscated<0x4A>("48 8D ?? ?? ?? ?? ?? EB ?? 48 8D ?? ?? ?? ?? ?? E8 ?? ?? ?? ?? C6 05 ?? ?? ?? ?? ?? 0F ?? ?? 4C");
            GNamesaddress = Memory::AOBScan(gameExecutable, GNamesStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
            constexpr auto AppendStringStringObfuscated = make_obfuscated<0x4A>("48 89 ?? ?? ?? 48 89 ?? ?? ?? 57 48 83 ?? ?? 80 3D ?? ?? ?? ?? ?? 48 8B F2 8B ?? 48");
            AppendStringaddress = Memory::AOBScan(gameExecutable, AppendStringStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
            constexpr auto ProcessEventStringObfuscated = make_obfuscated<0x4A>("40 ?? 56 57 41 ?? 41 ?? 41 ?? 41 ?? 48 81 ?? ?? ?? ?? ?? 48 8D ?? ?? ?? 48 89 ?? ?? ?? ?? ?? 48 8B ?? ?? ?? ?? ?? 48 33 ?? 48 89 ?? ?? ?? ?? ?? 4D ?? ?? 48");
            ProcessEventaddress = Memory::AOBScan(gameExecutable, ProcessEventStringObfuscated.decrypt(), PAGE_EXECUTE_READ);

            if (!GObjectsaddress)
                logger->warn("GObjects signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
            else {
                uint32_t gObjectsOffset = static_cast<uint32_t>(Memory::GetOffsetFromOpcode(GObjectsaddress + 0x3) -
                    reinterpret_cast<uint8_t*>(GetModuleHandleA(gameExecutable.c_str())));
                logger->info("GObjects offset is: 0x{:X}.", gObjectsOffset);
                Offsets::GObjects = static_cast<UC::uint32>(gObjectsOffset); // Update GObjects offset
            }

            if (!GNamesaddress)
                logger->warn("GNames signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
            else {
                uint32_t gNamesOffset = static_cast<uint32_t>(Memory::GetOffsetFromOpcode(GNamesaddress + 0x3) -
                    reinterpret_cast<uint8_t*>(GetModuleHandleA(gameExecutable.c_str())));
                logger->info("GNames offset is: 0x{:X}.", gNamesOffset);
                Offsets::GNames = static_cast<UC::uint32>(gNamesOffset); // Update GNames offset
            }

            if (!AppendStringaddress)
                logger->warn("AppendString signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
            else {
                std::optional<uint32_t> gAppendStringOffsetOpt = UE::CalculateOffset(gameExecutable, AppendStringaddress);  // Get Offset from opcode
                uint32_t gAppendStringOffset = *gAppendStringOffsetOpt;
                logger->info("AppendString offset is: 0x{:X}.", gAppendStringOffset);
                Offsets::AppendString = static_cast<UC::uint32>(gAppendStringOffset); // Update AppendString offset
            }

            if (!ProcessEventaddress)
                logger->warn("Process Event signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
            else {
                std::optional<uint32_t> gProcessEventOffsetOpt = UE::CalculateOffset(gameExecutable, ProcessEventaddress);
                uint32_t gProcessEventOffset = *gProcessEventOffsetOpt;
                logger->info("Process Event offset is: 0x{:X}.", gProcessEventOffset);
                Offsets::ProcessEvent = static_cast<UC::uint32>(gProcessEventOffset);// Update ProcessEvent offset
            }
        }

        logger->info("-------------- Fixes initialisation -------------");
    }
    if (g_fix_enabled) {
        if (FOVaddress) CameraFixEnabled(g_fov_fix_enabled, ECharlieCameraMode::FOV);
        if (Aspectaddress) AspectFixEnabled(g_aspect_fix_enabled);
        if (DOFaddress) DOFFixEnabled(g_DOF_fix_enabled);
        if (CAaddress) CAFixEnabled(g_CA_fix_enabled);
        if (Vignettingaddress) VignettingFixEnabled(g_Vignetting_fix_enabled);
        if (Fogaddress) FogFixEnabled(g_Fog_fix_enabled);
        if (Cameraaddress) CameraFixEnabled(g_Camera_fix_enabled, ECharlieCameraMode::Camera);
        if (GObjectsaddress && GNamesaddress && AppendStringaddress && ProcessEventaddress)
            HUDFixEnabled(g_HUD_fix_enabled);
    }
    else {
        if (FOVaddress) CameraFixEnabled(false, ECharlieCameraMode::FOV);
        if (Aspectaddress) AspectFixEnabled(false);
        if (DOFaddress) DOFFixEnabled(false);
        if (CAaddress) CAFixEnabled(false);
        if (Vignettingaddress) VignettingFixEnabled(false);
        if (Fogaddress) FogFixEnabled(false);
        if (Cameraaddress) CameraFixEnabled(false, ECharlieCameraMode::Camera);
        if (GObjectsaddress && GNamesaddress && AppendStringaddress && ProcessEventaddress)
            HUDFixEnabled(false);
        logger->info("All fixes disabled.");
    }
    if (!g_Console_Enabled && GObjectsaddress && GNamesaddress && AppendStringaddress && ProcessEventaddress) {
        EnableConsole();
    }
}

// Setters for Reshade addon call
extern "C" __declspec(dllexport) void SetFOVFixEnabled(bool enabled, bool init)
{
    g_fov_fix_enabled = enabled;
    if (!init) CameraFixEnabled(g_fov_fix_enabled, ECharlieCameraMode::FOV);
}

extern "C" __declspec(dllexport) void SetAspectRatioFixEnabled(bool enabled, bool init)
{
    g_aspect_fix_enabled = enabled;
    if (!init) AspectFixEnabled(g_aspect_fix_enabled);
}

extern "C" __declspec(dllexport) void SetDOFFixEnabled(bool enabled, bool init)
{
    g_DOF_fix_enabled = enabled;
    if (!init) DOFFixEnabled(g_DOF_fix_enabled);
}

extern "C" __declspec(dllexport) void SetCAFixEnabled(bool enabled, bool init)
{
    g_CA_fix_enabled = enabled;
    if (!init) CAFixEnabled(g_CA_fix_enabled);
}

extern "C" __declspec(dllexport) void SetVignettingFixEnabled(bool enabled, bool init)
{
    g_Vignetting_fix_enabled = enabled;
    if (!init) VignettingFixEnabled(g_Vignetting_fix_enabled);
}

extern "C" __declspec(dllexport) void SetFogFixEnabled(bool enabled, bool init)
{
    g_Fog_fix_enabled = enabled;
    if (!init) FogFixEnabled(g_Fog_fix_enabled);
}

extern "C" __declspec(dllexport) void SetCameraFixEnabled(bool enabled, bool init)
{
    g_Camera_fix_enabled = enabled;
    if (!init) CameraFixEnabled(g_Camera_fix_enabled, ECharlieCameraMode::Camera);
}

extern "C" __declspec(dllexport) void SetHUDFixEnabled(bool enabled, bool init)
{
    g_HUD_fix_enabled = enabled;
    if (!init) HUDFixEnabled(g_HUD_fix_enabled);
}

extern "C" __declspec(dllexport) void SetFOV(int fov)
{
    g_AdditionalFOVValue = fov;
}

extern "C" __declspec(dllexport) void SetCameraDistance(float cameraDistance)
{
    g_cameraDistanceMultiplier = cameraDistance;
}

extern "C" __declspec(dllexport) void SetCameraHeight(int cameraHeight)
{
    g_cameraHeight = (float)cameraHeight;
}

extern "C" __declspec(dllexport) void SetHUD(int HUDValue)
{
    float percentageLeft = (float)HUDValue / 100;
    float percentageRight = 1 - (float)HUDValue / 100;
    HUDAnchors = { { percentageLeft , 0.f }, { percentageRight , 1.f} };
}

// Getters for Reshade addon call
extern "C" __declspec(dllexport) float GetFOVIn() {
    return g_FOV_In;
}

extern "C" __declspec(dllexport) float GetCompensatedFOV() {
    return g_Compensated_FOV;
}

extern "C" __declspec(dllexport) float GetFOVOut() {
    return g_FOV_Out;
}

extern "C" __declspec(dllexport) bool GetConsoleEnabled() {
    return g_Console_Enabled;
}

// Code injection functions
// FOV compensation only
static void FOVFixEnabled(bool fix_enabled) {
    if (g_fix_enabled && fix_enabled && FOVaddress != nullptr) {
        if (!FOVHook) { // Hook only once
            FOVHook = safetyhook::create_mid(FOVaddress,
                [](SafetyHookContext& ctx) {
                    g_FOV_In = ctx.xmm0.f32[0];
                    if (g_aspect_fix_enabled)
                        g_Compensated_FOV = ctx.xmm0.f32[0] = Maths::CompensateHorizontalFOV(g_FOV_In, baseAspect, aspectRatio);
                    else
                        g_Compensated_FOV = ctx.xmm0.f32[0];
                    g_FOV_Out = ctx.xmm0.f32[0];
                });
        }
        else FOVHook.enable();
    }
    if (!fix_enabled && FOVHook)
        if (FOVHook) FOVHook.disable();
}

static void AspectFixEnabled(bool fix_enabled) {
    if (g_fix_enabled && fix_enabled && Aspectaddress) {
        if (!AspectHook) {
            AspectHook = safetyhook::create_mid(Aspectaddress,
                [](SafetyHookContext& ctx) {
                    ctx.rax = *reinterpret_cast<uint32_t*>(&aspectRatio);
                });
        }
        else AspectHook.enable();
        FOVFixEnabled(true);
        logger->info("Aspect fix enabled");
    }
    if (!fix_enabled) {
        if (AspectHook) AspectHook.disable();
        if (FOVHook && !g_fov_fix_enabled) FOVHook.disable();
        logger->info("Aspect ratio fix disabled");
    }
}

static void CameraFixEnabled(bool fix_enabled, ECharlieCameraMode mode) {
    if (g_fix_enabled && fix_enabled && Cameraaddress) {
        if (!CameraHook) { // Hook only once +0x4e or start to test +0x13
            CameraHook = safetyhook::create_mid(Cameraaddress + 0x4e,
                [](SafetyHookContext& ctx) {
                    ctx.xmm0.f32[0] *= (g_Camera_fix_enabled ? g_cameraDistanceMultiplier : 1.f);
                    // Retrieve player camera object
                    auto* charlieCameraBaseConfig = reinterpret_cast<UCharlieCameraBaseConfig*>(ctx.rax);
                    if (charlieCameraBaseConfig && charlieCameraBaseConfig->IsA(UCharlieCameraBaseConfig::StaticClass())) {
                        // Camera height
                        charlieCameraBaseConfig->DefaultHeightFromPlayer = (g_Camera_fix_enabled ? g_cameraHeight : DEFAULT_CAMERA_HEIGHT);
                        // World FOV
                        charlieCameraBaseConfig->FieldOfView = (g_fov_fix_enabled ? DEFAULT_WORLD_FOV + g_AdditionalFOVValue : DEFAULT_WORLD_FOV);
                    }
                });
        }
    }
    if (mode == ECharlieCameraMode::Camera) {
        if (g_Camera_fix_enabled) logger->info("Camera fix enabled");
        else logger->info("Camera fix disabled");
    }
    if (mode == ECharlieCameraMode::FOV) {
        if (g_fov_fix_enabled) logger->info("FOV fix enabled");
        else logger->info("FOV fix disabled");
    }
}

static void HUDFixEnabled(bool fix_enabled) {
    if (g_fix_enabled && fix_enabled && ProcessEventaddress) {
        if (!HUDHook) {
            HUDHook = safetyhook::create_mid(ProcessEventaddress + 0xc,
                [](SafetyHookContext& ctx) {
                    auto original_rdx = ctx.r8;
                    auto* object = reinterpret_cast<UObject*>(ctx.rcx);
                    auto* function = reinterpret_cast<UFunction*>(ctx.rdx);
                    // Filter object on Unreal User widgets
                    if (object && object->IsA(UUserWidget::StaticClass()) && function) {
                        std::string funcName = function->GetName();
                        std::string objectName = object->GetName();
                        // Filter by function construct
                        if (funcName == "Construct") {
                            auto* objectClass = object->Class;
                            std::string className = objectClass ? objectClass->GetName() : "Unknown";
                            auto* widget = static_cast<UUserWidget*>(object);
                            // Ensure the widget is of UCanvasPanelSlot & valid
                            if (widget && widget->Slot && widget->Slot->IsA(UCanvasPanelSlot::StaticClass())) {
                                auto* canvasSlot = static_cast<UCanvasPanelSlot*>(widget->Slot);

                                // Filter on class drawing HUD in game
                                if (canvasSlot && className.contains("CombatHud_SUMG_C")) {
                                    if (g_HUD_fix_enabled)
                                        canvasSlot->SetAnchors(HUDAnchors);
                                    else
                                        canvasSlot->SetAnchors(defaultHUDAnchors);
                                }
                            }
                        }
                    }
                });
        }
    }
}

// Memory patch fixes
static void DOFFixEnabled(bool fix_enabled) {
    if (g_fix_enabled && fix_enabled && DOFaddress) {
        Memory::PatchBytes(DOFaddress, "\x31\xF6\x90", 3); // xor esi,esi r.DepthOfFieldQuality = 0
        logger->info("Depth of field fix enabled");
    }
    if (!fix_enabled && DOFaddress) {
        Memory::RestoreBytes(DOFaddress);
        logger->info("Depth of field fix disabled");
    }
}

static void CAFixEnabled(bool fix_enabled) {
    if (g_CA_fix_enabled && fix_enabled && CAaddress) {
        Memory::PatchBytes(CAaddress, "\x90\x90", 2); // NOP jg "HellIsUs-Win64-Shipping.exe"+3D73BD5
        logger->info("Chromatics aberrations fix enabled");
    }
    if (!fix_enabled && CAaddress) {
        Memory::RestoreBytes(CAaddress);
        logger->info("Chromatics aberrations fix disabled");
    }
}

static void VignettingFixEnabled(bool fix_enabled) {
    if (g_fix_enabled && fix_enabled && Vignettingaddress) {
        Memory::PatchBytes(Vignettingaddress, "\x31\xC9", 2); // xor ecx,ecx r.Tonemapper.Quality=0
        logger->info("Vignetting fix enabled");
    }
    if (!fix_enabled && Vignettingaddress) {
        Memory::RestoreBytes(Vignettingaddress);
        logger->info("Vignetting fix disabled");
    }
}

static void FogFixEnabled(bool fix_enabled) {
    if (g_fix_enabled && fix_enabled && Fogaddress) {
        if (!FogHook) { // Hook only once
            FogHook = safetyhook::create_mid(Fogaddress,
                [](SafetyHookContext& ctx) {
                    ctx.rflags &= ~0x40; // ZF=0
                });
        }
        logger->info("Fog fix enabled");
    }
}

// UE Console creation
static void EnableConsole()
{
    logger->info("-------------- Console re-enabling --------------");
    if (!GObjectsaddress || !AppendStringaddress || !ProcessEventaddress) {
        logger->warn("Could not re-enable console");
        logger->info("------------------ User inputs ------------------");
        return;
    }

    std::thread([&]() {
        auto start = std::chrono::high_resolution_clock::now(); // Measure the time to renable console
        UEngine* Engine = nullptr;

        for (int i = 0; i < 100; ++i) { // gives 10 seconds to find UE Engine
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            Engine = UEngine::GetEngine();

            if (Engine && Engine->ConsoleClass && Engine->GameViewport)
                break;
        }

        if (!Engine || !Engine->ConsoleClass || !Engine->GameViewport) {
            logger->error("Console could not be found in engine.");
            return;
        }
        logger->info("Console found in engine");

        /* Creates a new UObject of class-type specified by Engine->ConsoleClass */
        UObject* NewObject = UGameplayStatics::SpawnObject(Engine->ConsoleClass, Engine->GameViewport);
        if (NewObject)
        {
            logger->info("Successfully spawned console object");
            // Set the console viewport so that it will be displayed
            Engine->GameViewport->ViewportConsole = static_cast<UConsole*>(NewObject);
            auto end = std::chrono::high_resolution_clock::now();
            std::chrono::duration<double> elapsed = end - start;

            // Set the all the console shortkey to F2
            for (int i = 0; i < UInputSettings::GetDefaultObj()->ConsoleKeys.Num(); i++)
            {
                UInputSettings::GetDefaultObj()->ConsoleKeys[i].KeyName = UKismetStringLibrary::Conv_StringToName(L"F2");
            }
            logger->info("Console fully reactivated in {:.3f}s and bound to key F2", elapsed.count());
            logger->info("------------------ User inputs ------------------");

            g_Console_Enabled = true;
        }
        else {
            logger->error("Could not spawn console object");
        }
    }).detach();
}

static void InitializeLogger()
{
    try
    {
        std::filesystem::path log_path = std::filesystem::absolute(PLUGIN_LOG);
        if (std::filesystem::exists(log_path))
            std::filesystem::remove(log_path);
        logger = std::make_shared<spdlog::logger>("Hell Is Us", std::make_shared<spdlog::sinks::rotating_file_sink_st>(PLUGIN_LOG, 10 * 1024 * 1024, 1));
        logger->set_level(spdlog::level::debug);
        logger->flush_on(spdlog::level::debug); // Flush automatically
    }
    catch (const spdlog::spdlog_ex& ex)
    {
        std::string plugin_error_message = "Could not open " + PLUGIN_LOG;
        MessageBoxA(nullptr, plugin_error_message.c_str(), "Logger Error", MB_ICONERROR | MB_OK);
    }
}

// Standard dll entry
BOOL APIENTRY DllMain(HMODULE hModule, DWORD reason, LPVOID)
{
    if (reason == DLL_PROCESS_ATTACH)
    {
        InitializeLogger();
        logger->info("Plugin {} loaded.", PLUGIN_NAME);
    }
    else if (reason == DLL_PROCESS_DETACH)
    {
        logger->info("Plugin {} unloaded.", PLUGIN_NAME);
        spdlog::drop_all();
    }
    return TRUE;
}