#include <Windows.h>
#include <d3d9.h>
#include <d3dx9.h>

#pragma comment (lib, "d3d9.lib")
#pragma comment (lib, "d3dx9.lib")
#pragma comment (lib, "winmm.lib")

//Win32 Stuff
LPCTSTR WndClassName = L"DirektSaft";
HWND hwnd = NULL;

const int Width = 1024;
const int Height = 768;

//--------DirectX Stuff
IDirect3D9* d3d9 = NULL;
IDirect3DDevice9* d3dev = NULL;

IDirect3DVertexBuffer9* VertexBuffer = 0;
IDirect3DIndexBuffer9* IndexBuffer = 0;

struct Vertex
{
	float x, y, z;
	float u,v;
};

const DWORD VertexFVF = D3DFVF_XYZ | D3DFVF_TEX1;

// VALUES

D3DXMATRIX WorldMatrixL;
D3DXMATRIX WorldMatrixR;
IDirect3DTexture9* Texture = 0;

//DirectX Prototypes
bool Setup();
void Clean();
bool Update(float deltaTime);
bool Render(float deltaTime);

//Win32 Prototypes--------
bool InitWindow(HINSTANCE hInstance, int ShowWnd, int width,
	int height, bool windowed, D3DDEVTYPE deviceType, IDirect3DDevice9** d3ddev);
int messageloop(bool (*display) (float deltaTime));
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
	if (!InitWindow(hInstance, nShowCmd, Width, Height, true,D3DDEVTYPE_HAL,&d3dev))
	{
		MessageBox(0, L"WIndow Init failed", L"ERROR", MB_OK);
		return 1;
	}

	if (!Setup())
	{
		MessageBox(0, L"Setup Scene failed", L"ERROR", MB_OK);
		return 1;
	}

	messageloop(Render);
	Clean();
	return 0;

}

bool InitWindow(HINSTANCE hInstance, int ShowWnd, int width, int height,
	bool windowed, D3DDEVTYPE deviceType, IDirect3DDevice9** d3ddev)
{
	WNDCLASSEX wc;

	wc.cbSize = sizeof(WNDCLASSEX);
	wc.style = CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc = WndProc;
	wc.cbWndExtra = NULL;
	wc.cbClsExtra = NULL;
	wc.hInstance = hInstance;
	wc.hIcon = LoadIcon(NULL, IDI_SHIELD);
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = (HBRUSH) COLOR_WINDOW + 1;
	wc.lpszMenuName = NULL;
	wc.lpszClassName = WndClassName;
	wc.hIconSm = LoadIcon(NULL, IDI_SHIELD);

	if (!RegisterClassEx(&wc))
	{
		MessageBox(0, L"Registering windows fauled", L"ERROR", MB_OK);
		return 1;
	}

	hwnd = CreateWindowEx(
		NULL, WndClassName, L"DirektSaftDemo",
		WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
		width, height, NULL, NULL, hInstance, NULL);

	if (!hwnd)
	{
		MessageBox(0, L"Create windowsEX faail", L"ERROR", MB_OK);
		return 1;
	}

	ShowWindow(hwnd, ShowWnd);
	UpdateWindow(hwnd);

	// DIRECTX INIT

	d3d9 = Direct3DCreate9(D3D_SDK_VERSION);
	if (!d3d9)
	{
		MessageBox(0, L"Init D3D fail", L"ERROR", MB_OK);
		return 1;
	}

	D3DCAPS9 caps;
	d3d9->GetDeviceCaps(D3DADAPTER_DEFAULT, deviceType, &caps);
	int vertexproc = NULL;
	if (caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
		vertexproc = D3DCREATE_HARDWARE_VERTEXPROCESSING;
	else
		vertexproc = D3DCREATE_SOFTWARE_VERTEXPROCESSING;

	D3DPRESENT_PARAMETERS d3dpp;
	d3dpp.BackBufferWidth = width;
	d3dpp.BackBufferHeight = height;
	d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
	d3dpp.BackBufferCount = 1;
	d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
	d3dpp.EnableAutoDepthStencil = true;
	d3dpp.Flags = NULL;
	d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
	d3dpp.hDeviceWindow = hwnd;
	d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
	d3dpp.MultiSampleQuality = NULL;
	d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	d3dpp.Windowed = windowed;

	HRESULT hr = 0;

	hr = d3d9->CreateDevice(D3DADAPTER_DEFAULT, deviceType, hwnd,
		vertexproc, &d3dpp, d3ddev);
	if (FAILED(hr))
	{
		MessageBox(0, L"Direct3D Device Failed", L"ERROR", MB_OK);
		d3d9->Release();
		return 1;
	}

	d3d9->Release();

	return true;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg)
	{
	  case WM_KEYDOWN:
		if (wParam == VK_ESCAPE)
		{
			DestroyWindow(hwnd);
		}
		return 0;

	 case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
	}
	return DefWindowProc(hwnd, msg, wParam, lParam);
}

int messageloop(bool (*display) (float deltaTime))
{
	MSG msg;
	ZeroMemory(&msg, sizeof(MSG));

	static float lastTime = (float)timeGetTime();

	while (true)
	{
		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			if (msg.message == WM_QUIT) break;
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		else
		{
			// GAME LOOP
			float curT = (float)timeGetTime();
			float deltaTime = (curT - lastTime) * 0.001f;
			 Update(deltaTime);
			 display( deltaTime);
			lastTime = curT;
		}

	}
	return (int)msg.wParam;
}

bool Setup()
{

	D3DXVECTOR3 CamPos(0.0f, 2.0f, -30.0f);
	D3DXVECTOR3 CamTarget(0.0f, 0.0f, 0.0f);
	D3DXVECTOR3 CamUp(0.0f, 1.0f, 0.0f);

	D3DXMATRIX View;
	D3DXMatrixLookAtLH(&View, &CamPos, &CamTarget, &CamUp);

	d3dev->SetTransform(D3DTS_VIEW, &View);

	D3DXMATRIX Projection;
	D3DXMatrixPerspectiveFovLH(
		&Projection,
		D3DX_PI * 0.5f,      //FOV Y
		(float)Width / (float)Height,   //Aspect Ratio (zb 16:9
		0.3f,				// Near Plane
		1000.0f);				//Far Plane

	d3dev->SetTransform(D3DTS_PROJECTION, &Projection);

	//------------------------------VERTEX BUFFER
	d3dev->CreateVertexBuffer(
		24 * sizeof(Vertex),
		D3DUSAGE_WRITEONLY,
		VertexFVF,
		D3DPOOL_MANAGED,
		&VertexBuffer,
		0);

	VOID* pVoid;

	Vertex vertices[] =
	{
		{ -3.0f, -3.0f, 3.0f, 1.0f, 1.0f,  },    // side 1
		{ 3.0f, -3.0f, 3.0f,  1.0f, 0.0f,   },
		{ -3.0f, 3.0f, 3.0f,  0.0f, 1.0f,   },
		{ 3.0f, 3.0f, 3.0f,   0.0f, 0.0f,    },

		{ -3.0f, -3.0f, -3.0f, 1.0f, 1.0f,   },    // side 2
		{ -3.0f, 3.0f, -3.0f,  1.0f, 0.0f,    },
		{ 3.0f, -3.0f, -3.0f,  0.0f, 1.0f,    },
		{ 3.0f, 3.0f, -3.0f,   0.0f, 0.0f,     },

		{ -3.0f, 3.0f, -3.0f, 1.0f, 1.0f,   },    // side 3
		{ -3.0f, 3.0f, 3.0f,  1.0f, 0.0f,    },
		{ 3.0f, 3.0f, -3.0f,  0.0f, 1.0f,    },
		{ 3.0f, 3.0f, 3.0f,   0.0f, 0.0f,     },

		{ -3.0f, -3.0f, -3.0f, 1.0f, 1.0f,   },    // side 4
		{ 3.0f, -3.0f, -3.0f,  1.0f, 0.0f,    },
		{ -3.0f, -3.0f, 3.0f,  0.0f, 1.0f,    },
		{ 3.0f, -3.0f, 3.0f,   0.0f, 0.0f,     },

		{ 3.0f, -3.0f, -3.0f, 1.0f, 1.0f,   },    // side 5
		{ 3.0f, 3.0f, -3.0f,  1.0f, 0.0f,    },
		{ 3.0f, -3.0f, 3.0f,  0.0f, 1.0f,    },
		{ 3.0f, 3.0f, 3.0f,   0.0f, 0.0f,     },

		{ -3.0f, -3.0f, -3.0f,1.0f, 1.0f, },    // side 6
		{ -3.0f, -3.0f, 3.0f, 1.0f, 0.0f,  },
		{ -3.0f, 3.0f, -3.0f, 0.0f, 1.0f,  },
		{ -3.0f, 3.0f, 3.0f,  0.0f, 0.0f,   },
	};
	VertexBuffer->Lock(0, 0, (void**)& pVoid, 0);
	memcpy(pVoid, vertices, sizeof(vertices));
	VertexBuffer->Unlock();

	//------------------------------------INDEX BUFFER

	WORD indices[] =
	{
        0, 1, 2,    // side 1
		2, 1, 3,
		4, 5, 6,    // side 2
		6, 5, 7,
		8, 9, 10,    // side 3
		10, 9, 11,
		12, 13, 14,    // side 4
		14, 13, 15,
		16, 17, 18,    // side 5
		18, 17, 19,
		20, 21, 22,    // side 6
		22, 21, 23,
	};

	d3dev->CreateIndexBuffer(36 * sizeof(WORD),0,D3DFMT_INDEX16,D3DPOOL_MANAGED,&IndexBuffer,NULL);


	IndexBuffer->Lock(0, 0, (void**)&pVoid, 0);
	memcpy(pVoid, indices, sizeof(indices));
	IndexBuffer->Unlock();

	// TEXTURE

	D3DXCreateTextureFromFile(d3dev, L"texture.jpg", &Texture);

	d3dev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
	d3dev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
	d3dev->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

	// RENDER STATES


	d3dev->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
	d3dev->SetRenderState(D3DRS_LIGHTING, false);
	d3dev->SetRenderState(D3DRS_SHADEMODE,D3DSHADE_GOURAUD);

	//d3dev->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);


	return true;
}
void Clean()
{
	VertexBuffer->Release();
	IndexBuffer->Release();
	Texture->Release();

	return;
}

bool Update(float deltaTime)
{
	D3DXMATRIX RotY;
	D3DXMATRIX RotX;
	D3DXMATRIX RotZ;
	D3DXMATRIX Scale;

	D3DXMATRIX TransLeft;
	D3DXMATRIX TransRight;
	static float y = 0;
	static float x = 0;
	static float z = 0;
	static float s = 0;

	D3DXMatrixRotationY(&RotY, y);
	D3DXMatrixRotationX(&RotX, x);
	D3DXMatrixRotationZ(&RotZ, z);

	float scale = 1.5f + (sin(s) * 0.5f);
	D3DXMatrixScaling(&Scale, scale, scale, scale);

	y += deltaTime * 1.5f;
	x += deltaTime * 1.7f;
	z += deltaTime * 1.3f;
	s += deltaTime * 2 * D3DX_PI;

	D3DXMatrixTranslation(&TransLeft, 0, 0, 0);
	D3DXMatrixTranslation(&TransRight, 4, 0, 0);

	WorldMatrixL = Scale * RotZ;
	WorldMatrixR = RotX * TransRight * RotY;

	return true;
}

bool Render(float deltaTime)
{
	if (d3dev)
	{
		d3dev->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00355DFF, 1.0f, 0);
		d3dev->BeginScene();

		d3dev->SetStreamSource(0, VertexBuffer, 0, sizeof(Vertex));
		d3dev->SetIndices(IndexBuffer);
		d3dev->SetFVF(VertexFVF);
		d3dev->SetTexture(0, Texture);
		// Linker WÜrfel
		d3dev->SetTransform(D3DTS_WORLD, &WorldMatrixL);
		d3dev->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 8, 0, 12);
		//Rechter WÜrfel
		d3dev->SetTransform(D3DTS_WORLD, &WorldMatrixR);
		d3dev->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 8, 0, 12);

		d3dev->EndScene();
		d3dev->Present(0, 0, 0, 0);
	}
	return true;
}