#include <windows.h>
#include <windowsx.h>
#include <d3d9.h>
#include <d3dx9.h>

#include "AxisRender.h"

#define WIDTH 800
#define HEIGTH 600

#pragma comment (lib, "d3d9.lib")
#pragma comment (lib, "d3dx9d.lib")

IDirect3D9* d3d;
IDirect3DDevice9* d3ddev;

void initD3D(HWND hWnd);
void render_frame(void);
void cleanD3D(void);

AxisRender* axis;

LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    HWND hWnd;
    WNDCLASSEX wc;

    memset(&wc, 0, sizeof(WNDCLASSEX));

    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.lpszClassName = L"WindowClass";

    RegisterClassEx(&wc);

    hWnd = CreateWindowEx   (
                                NULL,
                                L"WindowClass",
                                L"D3D",
                                WS_EX_TOPMOST | WS_POPUP,
                                0, 0,
                                WIDTH, HEIGTH,
                                NULL,
                                NULL,
                                hInstance,
                                NULL
                            );

    ShowWindow(hWnd, nCmdShow);

    initD3D(hWnd);

    MSG msg;

    axis = new AxisRender(200.0f, D3DCOLOR_XRGB(200, 200, 200));
    axis->InitVideoMemory(d3ddev);

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

        if(msg.message == WM_QUIT) break;

        render_frame();
    }

    cleanD3D();

    delete axis;

    return msg.wParam;
}

LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
        case WM_DESTROY:
            {
                PostQuitMessage(0);
                return 0;
            } break;
    }

    return DefWindowProc (hWnd, message, wParam, lParam);
}

void initD3D(HWND hWnd)
{
    d3d = Direct3DCreate9(D3D_SDK_VERSION);

    D3DPRESENT_PARAMETERS d3dpp;

    ZeroMemory(&d3dpp, sizeof(d3dpp));
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.hDeviceWindow = hWnd;
    d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
    d3dpp.BackBufferWidth = WIDTH;
    d3dpp.BackBufferHeight = HEIGTH;


    d3d->CreateDevice   (
                            D3DADAPTER_DEFAULT,
                            D3DDEVTYPE_HAL,
                            hWnd,
                            D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                            &d3dpp,
                            &d3ddev
                        );

    d3ddev->SetRenderState(D3DRS_LIGHTING, FALSE);
}

void render_frame(void)
{
    d3ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);

    d3ddev->BeginScene();

    // camera
    D3DXMATRIX viewMatrix;
    D3DXMatrixLookAtLH(&viewMatrix, &D3DXVECTOR3(10.0f, 4.0f, 5.0f), &D3DXVECTOR3(0.0f, 0.0f, 0.0f), &D3DXVECTOR3(0.0f, 1.0f, 0.0f));
    d3ddev->SetTransform(D3DTS_VIEW, &viewMatrix);

    D3DXMATRIX projMatrix;
    D3DXMatrixPerspectiveFovLH(&projMatrix, D3DXToRadian(45), (float)WIDTH / (float)HEIGTH, 1.0f, 100.0f);
    d3ddev->SetTransform(D3DTS_PROJECTION, &projMatrix);

    axis->Render();

    d3ddev->EndScene();

    d3ddev->Present(NULL, NULL, NULL, NULL);
}


void cleanD3D(void)
{
    d3ddev->Release();
    d3d->Release();
}