#include <windows.h>
#include <d3d11.h>
#include <dxgi.h>
#include <d3dcompiler.h>

#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "d3dcompiler.lib")

LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    return DefWindowProc(hwnd, msg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int)
{
    // Hidden window
    WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, WindowProc, 0L, 0L,
                      GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
                      L"VRAMKeepWindow", NULL };

    RegisterClassEx(&wc);

    HWND hwnd = CreateWindowW(L"VRAMKeepWindow", L"", WS_OVERLAPPEDWINDOW,
                              0, 0, 1920, 1080, NULL, NULL, wc.hInstance, NULL);

    ShowWindow(hwnd, SW_HIDE);

    // D3D11 init
    DXGI_SWAP_CHAIN_DESC sd = {};
    sd.BufferCount = 1;
    sd.BufferDesc.Width = 1920;
    sd.BufferDesc.Height = 1080;
    sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    sd.OutputWindow = hwnd;
    sd.SampleDesc.Count = 1;
    sd.Windowed = TRUE;
    sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;

    ID3D11Device* device = nullptr;
    ID3D11DeviceContext* context = nullptr;
    IDXGISwapChain* swapchain = nullptr;
    D3D_FEATURE_LEVEL featureLevel;

    if (FAILED(D3D11CreateDeviceAndSwapChain(
        nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0,
        nullptr, 0, D3D11_SDK_VERSION, &sd, &swapchain,
        &device, &featureLevel, &context)))
    {
        return 1;
    }

    // Render target
    ID3D11Texture2D* backBuffer = nullptr;
    ID3D11RenderTargetView* rtv = nullptr;
    swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&backBuffer);
    device->CreateRenderTargetView(backBuffer, nullptr, &rtv);
    if (backBuffer) backBuffer->Release();

    // Fullscreen triangle
    float vertices[] = {
        -1.0f, -1.0f, 0, 1,
         3.0f, -1.0f, 0, 1,
        -1.0f,  3.0f, 0, 1
    };

    D3D11_BUFFER_DESC vbDesc = {};
    vbDesc.ByteWidth = sizeof(vertices);
    vbDesc.Usage = D3D11_USAGE_DEFAULT;
    vbDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;

    D3D11_SUBRESOURCE_DATA vbData = {};
    vbData.pSysMem = vertices;

    ID3D11Buffer* vertexBuffer = nullptr;
    device->CreateBuffer(&vbDesc, &vbData, &vertexBuffer);

    // Input layout + vertex shader
    D3D11_INPUT_ELEMENT_DESC layout[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0,
          D3D11_INPUT_PER_VERTEX_DATA, 0 }
    };

    const char* vsCode =
        "float4 main(float4 pos : POSITION) : SV_POSITION { return pos; }";

    ID3DBlob* vsBlob = nullptr;
    D3DCompile(vsCode, strlen(vsCode), nullptr, nullptr, nullptr,
               "main", "vs_5_0", 0, 0, &vsBlob, nullptr);

    ID3D11VertexShader* vertexShader = nullptr;
    device->CreateVertexShader(vsBlob->GetBufferPointer(),
                               vsBlob->GetBufferSize(), nullptr, &vertexShader);

    ID3D11InputLayout* inputLayout = nullptr;
    device->CreateInputLayout(layout, 1,
                              vsBlob->GetBufferPointer(),
                              vsBlob->GetBufferSize(),
                              &inputLayout);

    vsBlob->Release();

    // Pixel shader (dark color)
    const char* psCode =
        "float4 main() : SV_Target { return float4(0.01, 0.01, 0.01, 1.0); }";

    ID3DBlob* psBlob = nullptr;
    D3DCompile(psCode, strlen(psCode), nullptr, nullptr, nullptr,
               "main", "ps_5_0", 0, 0, &psBlob, nullptr);

    ID3D11PixelShader* pixelShader = nullptr;
    device->CreatePixelShader(psBlob->GetBufferPointer(),
                              psBlob->GetBufferSize(), nullptr, &pixelShader);

    psBlob->Release();

    // Main loop
    MSG msg = {};
    UINT stride = 16;
    UINT offset = 0;

    while (true)
    {
        while (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        context->OMSetRenderTargets(1, &rtv, nullptr);
        context->IASetInputLayout(inputLayout);
        context->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
        context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
        context->VSSetShader(vertexShader, nullptr, 0);
        context->PSSetShader(pixelShader, nullptr, 0);
        context->Draw(3, 0);

        swapchain->Present(0, 0);
        Sleep(1); // Sleep(0) = maximale GPU-Last, Sleep(1) = VRAM hoch ohne 100% Load
    }

    return 0;
}