#include <d3dx9.h>
#include "DXUtil.h"
#include <iostream>

LPDIRECT3D9         g_pD3D = NULL;
LPDIRECT3DDEVICE9   g_pd3dDevice = NULL;
LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL;

struct Vertex
{
     float x, y, z;
     float color;
};

#define VERTEXFVF (D3DFVF_XYZ | D3DFVF_DIFFUSE)

void InitBuffer()
{
     D3DXMATRIX matProjection;
     BYTE *Ptr;

     Vertex Verts[4] = {
         {-50.0f,  50.0f, 0.0f, 0xffffffff},
         { 50.0f,  50.0f, 0.0f, 0xffffffff},
         {-50.0f, -50.0f, 0.0f, 0xffffffff},
         { 50.0f, -50.0f, 0.0f, 0xffffffff}
     };

     D3DXMatrixOrthoLH(&matProjection, 800, 600, 0, 10);
     g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProjection);

     g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
     g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, TRUE);

     g_pd3dDevice->CreateVertexBuffer(sizeof(Vertex)*4, 0, VERTEXFVF, D3DPOOL_DEFAULT, &g_pVB, NULL);
     g_pVB->Lock(0,0, (void**)&Ptr, 0);
     memcpy(Ptr, Verts, sizeof(Verts));
     g_pVB->Unlock();
}

HRESULT InitD3D( HWND hWnd, bool vsync)
{
     if(NULL == (g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)))
         return E_FAIL;

     D3DPRESENT_PARAMETERS d3dpp;
     ZeroMemory(&d3dpp, sizeof(d3dpp));
     d3dpp.Windowed         = TRUE;
     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
     d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
     d3dpp.EnableAutoDepthStencil = TRUE;
     d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
     d3dpp.BackBufferWidth  = GetSystemMetrics(SM_CXSCREEN);
     d3dpp.BackBufferHeight = GetSystemMetrics(SM_CYSCREEN);
     d3dpp.BackBufferCount = 3;

     d3dpp.PresentationInterval = !vsync ? D3DPRESENT_INTERVAL_IMMEDIATE : D3DPRESENT_INTERVAL_ONE;

     if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                    D3DCREATE_HARDWARE_VERTEXPROCESSING,
                    &d3dpp, &g_pd3dDevice)))
     {
         return E_FAIL;
     }

     g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
     g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);

     return S_OK;
}

VOID Cleanup()
{
     if( g_pVB != NULL )
         g_pVB->Release();

     if( g_pd3dDevice != NULL )
         g_pd3dDevice->Release();

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

float x, y;

int GetKeyUpState(DWORD button)
{
     return ((GetAsyncKeyState(button) & 0x8000) ? 0 : 1);
}

int GetKeyDownState(DWORD button)
{
     return ((GetAsyncKeyState(button) & 0x8000) ? 1 : 0);
}

int GetFPS()
{
     DWORD dwCurrentTime;
     DWORD dwElapsedTime;

     static DWORD dwLastUpdateTime;
     static DWORD dwFrames;
     static int fps;

     dwFrames++;
     dwCurrentTime = GetTickCount();
     dwElapsedTime = dwCurrentTime - dwLastUpdateTime;

     if(dwElapsedTime >= 1000)
     {
         fps = dwFrames * 1000.0 / dwElapsedTime;
         dwFrames = 0;
         dwLastUpdateTime = dwCurrentTime;
     }

     return fps;
}

int speed = 200;

VOID Render()
{
     FLOAT fElapsedAppTime = DXUtil_Timer(TIMER_GETELAPSEDTIME);
     FLOAT fps = GetFPS();

     std::cout << "DT: " << fElapsedAppTime << std::endl;
     std::cout << "FPS: " << fps << std::endl;

     D3DXMATRIX matWorld;

     if(GetKeyDownState(VK_LEFT)) x -= speed * fElapsedAppTime;
     if(GetKeyDownState(VK_RIGHT)) x += speed * fElapsedAppTime;

     D3DXMatrixTranslation(&matWorld, x, y, 0);
     g_pd3dDevice->SetTransform(D3DTS_WORLD, &matWorld);

     if( NULL == g_pd3dDevice )
         return;

     g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB( 200, 200, 200 ), 1.0f, 0 );

     g_pd3dDevice->BeginScene();

     g_pd3dDevice->SetStreamSource(0, g_pVB, 0, sizeof(Vertex));
     g_pd3dDevice->SetFVF(VERTEXFVF);

     g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);

     g_pd3dDevice->EndScene();

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

LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
     switch( msg )
     {
         case WM_DESTROY:
             PostQuitMessage( 0 );
             return 0;
     }

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

INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
{
     WNDCLASSEX wc =
     {
         sizeof( WNDCLASSEX ), CS_CLASSDC, MsgProc, 0L, 0L,
         GetModuleHandle( NULL ), NULL, NULL, NULL, NULL,
         "D3D Test", NULL
     };
     RegisterClassEx( &wc );

     HWND hWnd = CreateWindow( "D3D Test", "Test",
                    WS_OVERLAPPEDWINDOW, 100, 100, 800, 600,
                    NULL, NULL, wc.hInstance, NULL );

     if( SUCCEEDED(InitD3D(hWnd, false)))
     {
         InitBuffer();
         ShowWindow( hWnd, SW_SHOWDEFAULT );
         UpdateWindow( hWnd );

         MSG msg;
         while(msg.message != WM_QUIT)
         {
             if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
             {
                 TranslateMessage(&msg);
                 DispatchMessage(&msg);
             }
             else Render();
         }
     }

     Cleanup();

     UnregisterClass( "D3D Test", wc.hInstance );
     return 0;
}