#ifndef OVERLAY_HPP
#define OVERLAY_HPP

#include 
#include 
#include "render.hpp"

class c_overlay : public CefClient, public CefRenderHandler, public CefLifeSpanHandler {
public:
    c_overlay() = default;
    ~c_overlay() = default;

    virtual CefRefPtr GetRenderHandler() override { return this; };
    virtual CefRefPtr GetLifeSpanHandler() override { return this; }

    virtual void OnAfterCreated(CefRefPtr browser) override { this->browser = browser; }
 
    void OnPaint(CefRefPtr browser, PaintElementType type,
                const RectList& dirty_rects, const void* buffer, int width, int height) override;
    void GetViewRect(CefRefPtr browser, CefRect& rect) override {
        rect = CefRect(0, 0, 840, 660);
    };
 
    CefRefPtr GetBrowser() { return this->browser; };

private:
    CefRefPtr browser;

    IMPLEMENT_REFCOUNTING(c_overlay);
    DISALLOW_COPY_AND_ASSIGN(c_overlay);
};

namespace overlay {
    inline static c_overlay* cef;
    inline LPDIRECT3DTEXTURE9 texture = nullptr;
    inline int texture_width = 0;
    inline int texture_height = 0;

    void initialize();
    void create_browser(std::string url = "https://url.com");
    bool wnd_proc(HWND hwnd, UINT umsg, WPARAM wp, LPARAM lp);
    void destroy();
}

#endif // !OVERLAY_HPP

#include "overlay.hpp"

void c_overlay::OnPaint(CefRefPtr browser, PaintElementType type, const RectList& dirty_rects, const void* buffer, int width, int height) {
    if (!overlay::texture || width != overlay::texture_width || height != overlay::texture_height) {
        if (overlay::texture) {
            overlay::texture->Release();
            overlay::texture = nullptr;
        }
   
        if (D3DXCreateTexture(render::device, width, height, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &overlay::texture) == D3D_OK) {
            overlay::texture_width = width;
            overlay::texture_height = height;
        } else {
            return;
        }
    }

    D3DLOCKED_RECT locked_rect;
    if (overlay::texture->LockRect(0, &locked_rect, nullptr, D3DLOCK_DISCARD) == D3D_OK) {
        for (int y = 0; y (buffer) + y * width * 4;
            uint8_t* dst = static_cast(locked_rect.pBits) + y * locked_rect.Pitch;
            memcpy(dst, src, width * 4);
        }
        overlay::texture->UnlockRect(0);
    }
}

void overlay::create_browser(std::string url) {
    CefWindowInfo window_info;
    CefBrowserSettings browser_settings;
 
    browser_settings.windowless_frame_rate = 60;
    window_info.SetAsWindowless(nullptr);
 
    CefBrowserHost::CreateBrowser(window_info, cef, url.c_str(), browser_settings, nullptr, nullptr);
}

void overlay::initialize() {
    cef = new c_overlay();
 
    std::string work_path = std::filesystem::current_path().string();
    std::filesystem::create_directories(work_path + "\\cache");

    CefSettings settings;
    settings.windowless_rendering_enabled = true;
    settings.no_sandbox = true;
    settings.multi_threaded_message_loop = true;
    settings.background_color = 0x00000000; // Fully transparent
 
    CefString(&settings.browser_subprocess_path).FromASCII((work_path + "\\cef-sub-process.exe").c_str());
    CefString(&settings.cache_path).FromASCII((work_path + "\\cache").c_str());
    CefString(&settings.locales_dir_path).FromASCII((work_path + "\\locales").c_str());
    CefString(&settings.resources_dir_path) = work_path;
    CefString(&settings.locale).FromASCII("ru");
    CefString(&settings.accept_language_list).FromASCII("en-US,en,ru-RU,ru");

    CefMainArgs main_args;
    CefInitialize(main_args, settings, nullptr, nullptr);
 
    create_browser();
}

bool overlay::wnd_proc(HWND hwnd, UINT umsg, WPARAM wp, LPARAM lp) {
    if (!cef || !cef->GetBrowser())
        return false;

    CefRefPtr host = cef->GetBrowser()->GetHost();

    if (umsg >= WM_MOUSEFIRST && umsg SendMouseWheelEvent(mouse_event, 0, delta);
            return true;
        }
   
        if (umsg >= WM_LBUTTONDOWN && umsg SendMouseClickEvent(mouse_event, button, is_up, 1);
            return true;
        }
   
        host->SendMouseMoveEvent(mouse_event, false);
        return true;
    }

    if (umsg >= WM_KEYFIRST && umsg (wp);
        event.native_key_code = static_cast(lp);
   
        event.modifiers = 0;
        if (GetKeyState(VK_SHIFT) & 0x8000) event.modifiers |= EVENTFLAG_SHIFT_DOWN;
        if (GetKeyState(VK_CONTROL) & 0x8000) event.modifiers |= EVENTFLAG_CONTROL_DOWN;
        if (GetKeyState(VK_MENU) & 0x8000) event.modifiers |= EVENTFLAG_ALT_DOWN;
   
        if (umsg == WM_KEYDOWN || umsg == WM_SYSKEYDOWN) {
            event.type = KEYEVENT_RAWKEYDOWN;
        } else if (umsg == WM_KEYUP || umsg == WM_SYSKEYUP) {
            event.type = KEYEVENT_KEYUP;
        } else if (umsg == WM_CHAR) {
            event.type = KEYEVENT_CHAR;
        }
   
        if (event.windows_key_code == VK_ESCAPE && event.type == KEYEVENT_RAWKEYDOWN) {
            return false; // Let the game process ESC
        }
   
        host->SendKeyEvent(event);
        return true;
    }
 
    return false;
}

void overlay::destroy() {
    if (texture) {
        texture->Release();
        texture = nullptr;
    }
 
    CefShutdown();
    delete cef;
    cef = nullptr;
}

void c_plugin::update_hooked(const decltype(update_hook)& hook) {
    static bool inited = false;

    if (!inited && c_chat().reference() && rakhook::initialize()) {
        inited = true;
        overlay::initialize();
        render::initialize();
 
        render::on_present += []() {
            if (!overlay::texture || !render::device)
                return;

            DWORD old_z_enable, old_alpha_blend, old_src_blend, old_dest_blend, old_lighting;
            render::device->GetRenderState(D3DRS_ZENABLE, &old_z_enable);
            render::device->GetRenderState(D3DRS_ALPHABLENDENABLE, &old_alpha_blend);
            render::device->GetRenderState(D3DRS_SRCBLEND, &old_src_blend);
            render::device->GetRenderState(D3DRS_DESTBLEND, &old_dest_blend);
            render::device->GetRenderState(D3DRS_LIGHTING, &old_lighting);

            render::device->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
            render::device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
            render::device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
            render::device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
            render::device->SetRenderState(D3DRS_LIGHTING, FALSE);

            render::device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
            render::device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
            render::device->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
            render::device->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);

            struct CUSTOMVERTEX {
                FLOAT x, y, z, rhw;
                DWORD color;
                FLOAT u, v;
            };

            CUSTOMVERTEX vertices[] = {
                { 0.0f,   0.0f,   0.0f, 1.0f, 0xFFFFFFFF, 0.0f, 0.0f },
                { 840.0f, 0.0f,   0.0f, 1.0f, 0xFFFFFFFF, 1.0f, 0.0f },
                { 0.0f,   660.0f, 0.0f, 1.0f, 0xFFFFFFFF, 0.0f, 1.0f },
                { 840.0f, 660.0f, 0.0f, 1.0f, 0xFFFFFFFF, 1.0f, 1.0f }
            };

            render::device->SetFVF(D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1);
            render::device->SetTexture(0, overlay::texture);
            render::device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, vertices, sizeof(CUSTOMVERTEX));

            render::device->SetRenderState(D3DRS_ZENABLE, old_z_enable);
            render::device->SetRenderState(D3DRS_ALPHABLENDENABLE, old_alpha_blend);
            render::device->SetRenderState(D3DRS_SRCBLEND, old_src_blend);
            render::device->SetRenderState(D3DRS_DESTBLEND, old_dest_blend);
            render::device->SetRenderState(D3DRS_LIGHTING, old_lighting);
        };
    }
    return hook.call_trampoline();
}