// UniversalVRMenu.cpp - Compile as DLL, inject into Unity Player
// BepInEx plugin compatible - drop into BepInEx/plugins/

#include <Windows.h>
#include <string>
#include <unordered_map>
#include <vector>
#include <thread>
#include <chrono>
#include <fstream>
#include <cstring>

// --- MinHook / detour setup omitted for brevity ---
// In practice you'd link MinHook for function hooking

#pragma region Game Detection

enum class VRGame {
    Unknown,
    GorillaTag,
    Haymaker,
    RealmsVR   // UG
};

struct GameInfo {
    VRGame id;
    std::string displayName;
    std::string processName;
    std::string moduleSignature;  // UnityPlayer.dll hash or signature
    uint32_t steamAppId;
};

const std::unordered_map<std::string, GameInfo> GAME_DB = {
    {"Gorilla Tag.exe",      {VRGame::GorillaTag,  "Gorilla Tag",  "Gorilla Tag.exe",      "", 1533390}},
    {"GorillaTag.exe",       {VRGame::GorillaTag,  "Gorilla Tag",  "GorillaTag.exe",       "", 1533390}},
    {"gorillatag.exe",       {VRGame::GorillaTag,  "Gorilla Tag",  "gorillatag.exe",       "", 1533390}},
    {"Haymaker.exe",         {VRGame::Haymaker,    "Haymaker",     "Haymaker.exe",         "", 2855020}},
    {"Haymaker-Win64-Ship.exe", {VRGame::Haymaker, "Haymaker",     "Haymaker-Win64-Ship.exe", "", 2855020}},
    {"RealmsVR.exe",         {VRGame::RealmsVR,    "Realms VR",    "RealmsVR.exe",         "", 1624600}},
    {"RealmsVR-Win64-Shipping.exe", {VRGame::RealmsVR, "Realms VR",    "RealmsVR-Win64-Shipping.exe", "", 1624600}},
};

VRGame DetectCurrentGame() {
    char exePath[MAX_PATH];
    GetModuleFileNameA(NULL, exePath, MAX_PATH);
    std::string exeName = std::string(strrchr(exePath, '\\') + 1);
    
    auto it = GAME_DB.find(exeName);
    if (it != GAME_DB.end()) {
        return it->second.id;
    }
    return VRGame::Unknown;
}

#pragma endregion

#pragma region Game-Specific Feature Sets

// Each game gets its own feature map
struct FeatureToggle {
    std::string name;
    bool enabled;
    void (*enable)();
    void (*disable)();
};

class GameCheatEngine {
protected:
    std::vector<FeatureToggle> features;
    bool initialized = false;

public:
    virtual ~GameCheatEngine() = default;
    virtual void Initialize() = 0;
    virtual void RenderMenu() = 0;
    
    void ToggleFeature(int index) {
        if (index < 0 || index >= features.size()) return;
        features[index].enabled = !features[index].enabled;
        if (features[index].enabled) {
            if (features[index].enable) features[index].enable();
        } else {
            if (features[index].disable) features[index].disable();
        }
    }
    
    bool IsInitialized() { return initialized; }
};

// ─── Gorilla Tag Specific ───
class GorillaTagCheats : public GameCheatEngine {
    // Gorilla Tag is a Gorilla Tag mod menu
    // - Long arms / reach
    // - Wallhack (disable occlusion)
    // - Speed modifier
    // - No tag cooldown (monke)
    // - Ghost / invisible
    // - ESP box
    // - Disable game boundaries
    
    uintptr_t baseAddress = 0;
    
    void FindBaseAddress() {
        HMODULE hGame = GetModuleHandleA("GameAssembly.dll");
        if (hGame) baseAddress = (uintptr_t)hGame;
    }
    
public:
    void Initialize() override {
        FindBaseAddress();
        
        features = {
            {"Long Arms (2.5x)", false, 
                [this]() { /* Write 2.5f to player scale */ }, 
                [this]() { /* Write 1.0f */ }},
            {"No Tag Cooldown", false,
                [this]() { /* NOP tag cooldown check */ },
                [this]() { /* Restore bytes */ }},
            {"Wallhack (Disable Occlusion)", false,
                [this]() { /* Set camera occlusion culling false */ },
                [this]() { /* Set back */ }},
            {"Speed Boost (2.0x)", false, nullptr, nullptr},
            {"Ghost Mode (Other players can't tag)", false, nullptr, nullptr},
            {"ESP Box (Show players through walls)", false, nullptr, nullptr},
            {"Disable Boundary (Leave map)", false, nullptr, nullptr},
            {"Auto-Tag (Reach + auto)", false, nullptr, nullptr},
        };
        initialized = true;
    }
    
    void RenderMenu() override {
        // Rendered via ImGui inside Unity
    }
};

// ─── Haymaker Specific ───
class HaymakerCheats : public GameCheatEngine {
public:
    void Initialize() override {
        features = {
            {"Aimbot / Auto-Punch", false, nullptr, nullptr},
            {"No Stamina Drain", false, nullptr, nullptr},
            {"Super Speed", false, nullptr, nullptr},
            {"ESP Box", false, nullptr, nullptr},
            {"Invincibility", false, nullptr, nullptr},
            {"Infinite Special Meter", false, nullptr, nullptr},
            {"Slow Motion (Speed Hack)", false, nullptr, nullptr},
        };
        initialized = true;
    }
    
    void RenderMenu() override {}
};

// ─── Realms VR (UG) Specific ───
class RealmsVRCheats : public GameCheatEngine {
public:
    void Initialize() override {
        features = {
            {"Aimbot", false, nullptr, nullptr},
            {"ESP / Player Chams", false, nullptr, nullptr},
            {"Speed Hack", false, nullptr, nullptr},
            {"Fly Mode", false, nullptr, nullptr},
            {"No Clip", false, nullptr, nullptr},
            {"Infinite Health", false, nullptr, nullptr},
            {"Rapid Fire", false, nullptr, nullptr},
            {"No Recoil / Spread", false, nullptr, nullptr},
        };
        initialized = true;
    }
    
    void RenderMenu() override {}
};

#pragma endregion

#pragma region Universal Menu System

class UniversalVRMenu {
private:
    VRGame detectedGame = VRGame::Unknown;
    GameCheatEngine* activeEngine = nullptr;
    bool menuVisible = true;
    HANDLE hConsole = NULL;
    
    std::unique_ptr<GorillaTagCheats> gorillaEngine;
    std::unique_ptr<HaymakerCheats> haymakerEngine;
    std::unique_ptr<RealmsVRCheats> realmsEngine;

public:
    bool Initialize() {
        detectedGame = DetectCurrentGame();
        
        if (detectedGame == VRGame::Unknown) {
            // Try to scan memory for game signatures instead
            detectedGame = ScanForGameByMemorySignature();
        }
        
        switch (detectedGame) {
            case VRGame::GorillaTag:
                gorillaEngine = std::make_unique<GorillaTagCheats>();
                gorillaEngine->Initialize();
                activeEngine = gorillaEngine.get();
                break;
            case VRGame::Haymaker:
                haymakerEngine = std::make_unique<HaymakerCheats>();
                haymakerEngine->Initialize();
                activeEngine = haymakerEngine.get();
                break;
            case VRGame::RealmsVR:
                realmsEngine = std::make_unique<RealmsVRCheats>();
                realmsEngine->Initialize();
                activeEngine = realmsEngine.get();
                break;
            default:
                return false;
        }
        
        return activeEngine && activeEngine->IsInitialized();
    }
    
    VRGame ScanForGameByMemorySignature() {
        // Scan process memory for known Unity strings
        // Example: search for "GorillaPlayer" in loaded assemblies
        // This is game-specific memory scanning
        return VRGame::Unknown;
    }
    
    void RenderOverlay() {
        if (!menuVisible || !activeEngine) return;
        
        // In practice, this hooks into Unity's OnGUI or uses ImGui overlay
        // For standalone: creates transparent overlay window + DirectX hooks
        
        // ─── Render Header ───
        const char* gameName = "Unknown";
        switch (detectedGame) {
            case VRGame::GorillaTag: gameName = "Gorilla Tag"; break;
            case VRGame::Haymaker:   gameName = "Haymaker";    break;
            case VRGame::RealmsVR:   gameName = "Realms VR (UG)"; break;
        }
        
        // Draw box background
        // Draw title: "Universal VR Menu — {gameName}"
        
        // ─── Render Toggles ───
        for (size_t i = 0; i < activeEngine->features.size(); i++) {
            auto& f = activeEngine->features[i];
            // Draw checkbox: [X] feature.name  (toggle on click)
        }
        
        // ─── Hotkeys ───
        // INSERT = toggle menu visibility
        // Arrow keys / mouse = navigate
    }
    
    void SetMenuVisible(bool vis) { menuVisible = vis; }
    bool IsMenuVisible() { return menuVisible; }
    VRGame GetDetectedGame() { return detectedGame; }
};

#pragma endregion

// ─── Entry Point (DLL Main) ───
DWORD WINAPI MainThread(LPVOID lpParam) {
    AllocConsole();
    FILE* f;
    freopen_s(&f, "CONOUT$", "w", stdout);
    
    std::cout << "[UniversalVR] Initializing...\n";
    
    UniversalVRMenu menu;
    if (menu.Initialize()) {
        std::cout << "[UniversalVR] Detected: " << (int)menu.GetDetectedGame() << "\n";
        std::cout << "[UniversalVR] Menu loaded. Press INSERT to toggle.\n";
        
        // Main loop
        while (true) {
            if (GetAsyncKeyState(VK_INSERT) & 1) {
                menu.SetMenuVisible(!menu.IsMenuVisible());
            }
            
            if (menu.IsMenuVisible()) {
                menu.RenderOverlay();
            }
            
            Sleep(16); // ~60fps
        }
    } else {
        std::cout << "[UniversalVR] Unknown game. Scanning for signatures...\n";
        // Fallback: generic Unity explorer
    }
    
    return 0;
}

BOOL APIENTRY DllMain(HMODULE hModule, DWORD reason, LPVOID lpReserved) {
    if (reason == DLL_PROCESS_ATTACH) {
        DisableThreadLibraryCalls(hModule);
        CreateThread(NULL, 0, MainThread, NULL, 0, NULL);
    }
    return TRUE;
}