// dllmain.cpp : Defines the entry point for the DLL application.
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
#pragma comment(lib, "detours.lib")

#include <Windows.h>
#include <iostream>
#include <string>
#include <Detours.h>
#include <imgui.h>
#include "imgui.h"
#include "imgui_impl_dx9.h"
#include "imgui_impl_win32.h"
#include <d3d9.h>
#include <d3dx9.h>

typedef HRESULT(_stdcall* EndScene)(LPDIRECT3DDEVICE9 pDevice);
HRESULT _stdcall hkEndScene(LPDIRECT3DDEVICE9 pDevice);
EndScene oEndScene;

LPDIRECT3DDEVICE9    g_pd3dDevice = NULL;
IDirect3D9 *         g_pD3D = NULL;
HWND                 window = NULL;
WNDPROC              wndproc_orig = NULL;

bool show_menu = false;
bool chams = true;

BOOL CALLBACK EnumWindowsCallback(HWND handle, LPARAM lParam)
{
    DWORD wndProcID;
    GetWindowThreadProcessId(handle, &wndProcID);

    if (GetCurrentProcessId() != wndProcID)
    {
        return TRUE;
    }

    window = handle;
    return FALSE;
}

HWND GetProcessWindow()
{
    EnumWindows(EnumWindowsCallback, NULL);
    return window;
}

extern LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT __stdcall WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    if (show_menu && ImGui_ImplWin32_WndProcHandler(hWnd, msg, wParam, lParam))
    {
        return true;
    }
    return CallWindowProc(wndproc_orig, hWnd, msg, wParam, lParam);
}

bool GetD3D9Device(void ** pTable, size_t size)
{
    if (!pTable)
    {
        return false;
    }

    g_pD3D = Direct3DCreate9(D3D_SDK_VERSION);

    if (!g_pD3D)
    {
        return false;
    }

    D3DPRESENT_PARAMETERS d3dpp = {};
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.hDeviceWindow = GetProcessWindow();
    d3dpp.Windowed = true;

    g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, d3dpp.hDeviceWindow,
        D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &g_pd3dDevice);

    if (!g_pd3dDevice)
    {
        g_pD3D->Release();
        return false;
    }

    memcpy(pTable, *reinterpret_cast<void***>(g_pd3dDevice), size);
    g_pd3dDevice->Release();
    g_pD3D->Release();
    return true;
}

void CleanupDeviceD3D()
{
    if (g_pd3dDevice)
    {
        g_pd3dDevice->Release();
        g_pd3dDevice = NULL;
    }

    if (g_pD3D)
    {
        g_pD3D->Release();
        g_pD3D = NULL;
    }
}

HRESULT __stdcall hkEndScene(LPDIRECT3DDEVICE9 pDevice)
{
    static bool init = false;

    if (GetAsyncKeyState(VK_INSERT) & 1)
    {
        show_menu = !show_menu;
    }

    if (!init)
    {
        wndproc_orig = (WNDPROC)SetWindowLongPtr(window, GWL_WNDPROC, (LONG_PTR)WndProc);

        ImGui::CreateContext();
        ImGuiIO& io = ImGui::GetIO();

        ImGui::StyleColorsDark();

        ImGui_ImplWin32_Init(window);
        ImGui_ImplDX9_Init(pDevice);

        init = true;
    }

    if (init)
    {
        if (show_menu)
        {
            ImGui_ImplDX9_NewFrame();
            ImGui_ImplWin32_NewFrame();
            ImGui::NewFrame();

            /* ImGui::Begin("Menu", &show_menu);
            {
                ImGui::Checkbox("Chams", &chams);
            }
            */

            ImGui::Text("Hello, world!");

            ImGui::Render();
            ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData());
        }
    }

    return oEndScene(pDevice);
}

DWORD WINAPI mainThread(PVOID base)
{
    void* d3d9Device[119];

    if (GetD3D9Device(d3d9Device, sizeof(d3d9Device)))
    {
        oEndScene = (EndScene)Detours::X86::DetourFunction((Detours::uint8_t*)d3d9Device[42], (Detours::uint8_t*)hkEndScene);

        while (true)
        {
            if (GetAsyncKeyState(VK_F10))
            {
                CleanupDeviceD3D();
                FreeLibraryAndExitThread(static_cast<HMODULE>(base), 1);
            }
        }
    }

    FreeLibraryAndExitThread(static_cast<HMODULE>(base), 1);
}

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        CreateThread(nullptr, NULL, mainThread, hModule, NULL, nullptr);
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}