#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 uMsg, WPARAM wParam, LPARAM lParam) {
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int) {
    // Verstecktes Fenster einrichten
    WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, WindowProc, 0L, 0L,
                      GetModuleHandle(nullptr), nullptr, nullptr, nullptr, nullptr,
                      L"VRAMKeepWindow", nullptr };
    RegisterClassEx(&wc);
    HWND hwnd = CreateWindowW(L"VRAMKeepWindow", L"", WS_OVERLAPPEDWINDOW, 0, 0, 1920, 1080,
                             nullptr, nullptr, wc.hInstance, nullptr);
    ShowWindow(hwnd, SW_HIDE);

    // D3D11 Initialization
    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 fl;

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

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

    // Fullscreen Triangle Vertex Buffer
    float vertices[] = {
        -1.0f, -1.0f, 0.0f, 1.0f,
         3.0f, -1.0f, 0.0f, 1.0f,
        -1.0f,  3.0f, 0.0f, 1.0f
    };
    D3D11_BUFFER_DESC vbDesc = {};
    vbDesc.ByteWidth = sizeof(vertices);
    vbDesc.Usage = D3D11_USAGE_DEFAULT;
    vbDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    D3D11_SUBRESOURCE_DATA vbData = { vertices };
    ID3D11Buffer* vertexBuffer = nullptr;
    device->CreateBuffer(&vbDesc, &vbData, &vertexBuffer);

    // Input Layout for Position Only
    D3D11_INPUT_ELEMENT_DESC layout[] = {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0,
          D3D11_INPUT_PER_VERTEX_DATA, 0 }
    };
    ID3D11InputLayout* inputLayout = nullptr;
    ID3DBlob* vsBlob = nullptr;
    D3DCompile("float4 main(float4 pos : POSITION) : SV_POSITION { return pos; }",
        strlen("float4 main(float4 pos : POSITION) : SV_POSITION { return pos; }"),
        nullptr, nullptr, nullptr, "main", "vs_5_0", 0, 0, &vsBlob, nullptr);
    ID3D11VertexShader* vertexShader = nullptr;
    device->CreateVertexShader(vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(),
                               nullptr, &vertexShader);
    device->CreateInputLayout(layout, 1, vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(), &inputLayout);
    vsBlob->Release();

    // Simple Pixel Shader (dark color)
    ID3DBlob* psBlob = nullptr;
    D3DCompile("float4 main() : SV_Target { return float4(0.01, 0.01, 0.01, 1.0); }",
        strlen("float4 main() : SV_Target { return float4(0.01, 0.01, 0.01, 1.0); }"),
        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, nullptr, 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);  // No VSync
        Sleep(1);  // Optional: Sleep(0) für maximale Last, Sleep(1) für "Takt oben halten ohne 100% Last"
    }

    // Cleanup (never reached)
    if (pixelShader) pixelShader->Release();
    if (vertexShader) vertexShader->Release();
    if (inputLayout) inputLayout->Release();
    if (vertexBuffer) vertexBuffer->Release();
    if (rtv) rtv->Release();
    if (swapchain) swapchain->Release();
    if (context) context->Release();
    if (device) device->Release();

    return 0;
}