---

#include "overlay.h"
#include "menu.h"
#include "config.h"
#include "esp.h"
#include <dwmapi.h>
#include <iostream>

extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

#pragma comment(lib, "dwmapi.lib")

static Overlay* g_pOverlay = nullptr;
static bool g_bExclusiveMode = false;

Overlay::Overlay()
    : m_hGameWnd(nullptr), m_hOverlayWnd(nullptr), m_hInstance(nullptr),
      m_pDevice(nullptr), m_pContext(nullptr), m_pSwapChain(nullptr),
      m_pRenderTargetView(nullptr), m_bInitialized(false), m_bMenuOpen(true),
      m_width(1920), m_height(1080) {
    g_pOverlay = this;
}

Overlay::~Overlay() {
    Destroy();
}

bool Overlay::Create(HWND hGameWnd) {
    if (m_bInitialized) return true;
    
    m_hGameWnd = hGameWnd;
    m_hInstance = GetModuleHandle(nullptr);
    
    // Получаем размеры окна игры
    RECT rect;
    GetWindowRect(m_hGameWnd, &rect);
    m_width = rect.right - rect.left;
    m_height = rect.bottom - rect.top;
    
    std::cout << "[+] Game window size: " << m_width << "x" << m_height << std::endl;
    std::cout << "[+] Game window HWND: 0x" << std::hex << (uintptr_t)m_hGameWnd << std::endl;
    
    // ============================================
    // РЕГИСТРИРУЕМ КЛАСС ДЛЯ ОВЕРЛЕЙНОГО ОКНА
    // ============================================
    WNDCLASSEXA wc = {};
    wc.cbSize = sizeof(WNDCLASSEXA);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = Overlay::WndProc;
    wc.hInstance = m_hInstance;
    wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wc.lpszClassName = "CS2OverlayClass";
    
    if (!RegisterClassExA(&wc)) {
        DWORD err = GetLastError();
        if (err != ERROR_CLASS_ALREADY_EXISTS) {
            std::cout << "[-] RegisterClassEx failed: " << err << std::endl;
            return false;
        }
        std::cout << "[+] Window class already exists!" << std::endl;
    } else {
        std::cout << "[+] Window class registered!" << std::endl;
    }
    
    // ============================================
    // СОЗДАЕМ ОВЕРЛЕЙНОЕ ОКНО
    // ============================================
    m_hOverlayWnd = CreateWindowExA(
        WS_EX_TOPMOST | WS_EX_LAYERED | WS_EX_TRANSPARENT,
        "CS2OverlayClass",
        "CS2 External Overlay",
        WS_POPUP,
        rect.left, rect.top,
        m_width, m_height,
        nullptr, nullptr, m_hInstance, nullptr
    );
    
    if (!m_hOverlayWnd) {
        std::cout << "[-] CreateWindowEx failed: " << GetLastError() << std::endl;
        return false;
    }
    
    std::cout << "[+] Overlay window created!" << std::endl;
    
    // Настраиваем прозрачность
    SetLayeredWindowAttributes(m_hOverlayWnd, RGB(0, 0, 0), 0, LWA_COLORKEY);
    ShowWindow(m_hOverlayWnd, SW_SHOW);
    UpdateWindow(m_hOverlayWnd);
    
    // ============================================
    // СОЗДАЕМ DIRECTX ДЛЯ ОВЕРЛЕЙНОГО ОКНА
    // ============================================
    if (!CreateDevice()) {
        std::cout << "[-] Failed to create DirectX device!" << std::endl;
        return false;
    }
    
    // ============================================
    // ИНИЦИАЛИЗИРУЕМ IMGUI
    // ============================================
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    
    ImGuiIO& io = ImGui::GetIO();
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
    io.IniFilename = nullptr;
    
    ImGuiStyle& style = ImGui::GetStyle();
    style.WindowRounding = 8.0f;
    style.FrameRounding = 4.0f;
    style.GrabRounding = 4.0f;
    
    ImVec4* colors = style.Colors;
    colors[ImGuiCol_WindowBg] = ImVec4(0.08f, 0.08f, 0.12f, 0.95f);
    colors[ImGuiCol_ChildBg] = ImVec4(0.06f, 0.06f, 0.09f, 0.80f);
    colors[ImGuiCol_Header] = ImVec4(0.12f, 0.12f, 0.20f, 0.80f);
    colors[ImGuiCol_HeaderHovered] = ImVec4(0.00f, 0.40f, 0.80f, 0.80f);
    colors[ImGuiCol_HeaderActive] = ImVec4(0.00f, 0.50f, 1.00f, 1.00f);
    colors[ImGuiCol_Button] = ImVec4(0.15f, 0.15f, 0.25f, 0.80f);
    colors[ImGuiCol_ButtonHovered] = ImVec4(0.00f, 0.40f, 0.80f, 0.80f);
    colors[ImGuiCol_ButtonActive] = ImVec4(0.00f, 0.50f, 1.00f, 1.00f);
    colors[ImGuiCol_CheckMark] = ImVec4(0.00f, 0.50f, 1.00f, 1.00f);
    colors[ImGuiCol_SliderGrab] = ImVec4(0.00f, 0.50f, 1.00f, 1.00f);
    colors[ImGuiCol_SliderGrabActive] = ImVec4(0.00f, 0.70f, 1.00f, 1.00f);
    colors[ImGuiCol_Tab] = ImVec4(0.10f, 0.10f, 0.16f, 0.80f);
    colors[ImGuiCol_TabHovered] = ImVec4(0.00f, 0.40f, 0.80f, 0.80f);
    colors[ImGuiCol_TabActive] = ImVec4(0.00f, 0.50f, 1.00f, 1.00f);
    colors[ImGuiCol_Text] = ImVec4(0.90f, 0.90f, 0.95f, 1.00f);
    colors[ImGuiCol_FrameBg] = ImVec4(0.12f, 0.12f, 0.20f, 0.80f);
    colors[ImGuiCol_FrameBgHovered] = ImVec4(0.00f, 0.40f, 0.80f, 0.80f);
    colors[ImGuiCol_FrameBgActive] = ImVec4(0.00f, 0.50f, 1.00f, 1.00f);
    
    if (!ImGui_ImplWin32_Init(m_hOverlayWnd)) {
        std::cout << "[-] Failed to init ImGui Win32!" << std::endl;
        return false;
    }
    
    if (!ImGui_ImplDX11_Init(m_pDevice, m_pContext)) {
        std::cout << "[-] Failed to init ImGui DX11!" << std::endl;
        return false;
    }
    
    Config::Load();
    
    m_bInitialized = true;
    std::cout << "[+] Overlay initialized!" << std::endl;
    std::cout << "[+] Press PGDN (Page Down) to open menu" << std::endl;
    std::cout << "[+] Press F1 to toggle ESP" << std::endl;
    std::cout << "[+] Press END to exit" << std::endl;
    
    return true;
}

bool Overlay::CreateDevice() {
    DXGI_SWAP_CHAIN_DESC scd = {};
    scd.BufferCount = 1;
    scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    scd.BufferDesc.Width = m_width;
    scd.BufferDesc.Height = m_height;
    scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    scd.OutputWindow = m_hOverlayWnd;
    scd.SampleDesc.Count = 1;
    scd.Windowed = TRUE;
    
    D3D_FEATURE_LEVEL featureLevels[] = { D3D_FEATURE_LEVEL_11_0 };
    
    HRESULT hr = D3D11CreateDeviceAndSwapChain(
        nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0,
        featureLevels, 1, D3D11_SDK_VERSION,
        &scd, &m_pSwapChain, &m_pDevice, nullptr, &m_pContext
    );
    
    if (FAILED(hr)) {
        std::cout << "[-] D3D11CreateDeviceAndSwapChain failed: 0x" << std::hex << hr << std::endl;
        return false;
    }
    
    ID3D11Texture2D* pBackBuffer;
    m_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&pBackBuffer);
    m_pDevice->CreateRenderTargetView(pBackBuffer, nullptr, &m_pRenderTargetView);
    pBackBuffer->Release();
    
    return true;
}

void Overlay::ToggleMenu() {
    m_bMenuOpen = !m_bMenuOpen;
    std::cout << "[+] Menu: " << (m_bMenuOpen ? "OPEN" : "CLOSED") << std::endl;
}

void Overlay::Render(const std::vector<PlayerData>& players) {
    if (!m_bInitialized) return;
    
    ImGui_ImplDX11_NewFrame();
    ImGui_ImplWin32_NewFrame();
    ImGui::NewFrame();
    
    // ============================================
    // ТЕСТОВЫЙ ТЕКСТ (всегда виден)
    // ============================================
    ImGui::GetForegroundDrawList()->AddText(
        ImVec2(10, 10),
        IM_COL32(0, 255, 0, 255),
        "[IMGUI] WORKING! Press PGDN for menu | F1=ESP"
    );
    // ============================================
    
    if (m_bMenuOpen) {
        Menu::Draw();
    }
    
    if (Menu::g_bESP) {
        DrawESP(players);
    }
    
    if (Config::g_bCrosshair) {
        DrawCrosshair();
    }
    
    ImGui::EndFrame();
    ImGui::Render();
    
    float clearColor[] = { 0.0f, 0.0f, 0.0f, 0.0f };
    m_pContext->ClearRenderTargetView(m_pRenderTargetView, clearColor);
    
    ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
    
    m_pSwapChain->Present(1, 0);
}

void Overlay::Destroy() {
    if (m_pRenderTargetView) {
        m_pRenderTargetView->Release();
        m_pRenderTargetView = nullptr;
    }
    if (m_pSwapChain) {
        m_pSwapChain->Release();
        m_pSwapChain = nullptr;
    }
    if (m_pContext) {
        m_pContext->Release();
        m_pContext = nullptr;
    }
    if (m_pDevice) {
        m_pDevice->Release();
        m_pDevice = nullptr;
    }
    
    ImGui_ImplDX11_Shutdown();
    ImGui_ImplWin32_Shutdown();
    ImGui::DestroyContext();
    
    if (m_hOverlayWnd) {
        DestroyWindow(m_hOverlayWnd);
        m_hOverlayWnd = nullptr;
    }
    
    m_bInitialized = false;
}

LRESULT CALLBACK Overlay::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    if (g_pOverlay) {
        return g_pOverlay->HandleMessage(msg, wParam, lParam);
    }
    return DefWindowProc(hwnd, msg, wParam, lParam);
}

LRESULT Overlay::HandleMessage(UINT msg, WPARAM wParam, LPARAM lParam) {
    if (m_bInitialized) {
        if (ImGui_ImplWin32_WndProcHandler(m_hOverlayWnd, msg, wParam, lParam)) {
            return true;
        }
    }
    
    switch (msg) {
    case WM_KEYDOWN:
        if (wParam == VK_NEXT) {  // PGDN
            ToggleMenu();
            return 0;
        }
        if (wParam == VK_END) {
            Destroy();
            PostQuitMessage(0);
            return 0;
        }
        if (wParam == VK_F1) {
            Menu::g_bESP = !Menu::g_bESP;
            std::cout << "[+] ESP: " << (Menu::g_bESP ? "ON" : "OFF") << std::endl;
            return 0;
        }
        if (wParam == VK_F2) {
            Menu::g_bAimbot = !Menu::g_bAimbot;
            std::cout << "[+] Aimbot: " << (Menu::g_bAimbot ? "ON" : "OFF") << std::endl;
            return 0;
        }
        if (wParam == VK_F3) {
            Menu::g_bTriggerbot = !Menu::g_bTriggerbot;
            std::cout << "[+] Triggerbot: " << (Menu::g_bTriggerbot ? "ON" : "OFF") << std::endl;
            return 0;
        }
        break;
        
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    
    return DefWindowProc(m_hOverlayWnd, msg, wParam, lParam);
}