#pragma warning (disable:4996)
#pragma comment (lib, "d3d11.lib")
#pragma comment (lib, "d3dx11.lib")
#pragma comment (lib, "d3dx10.lib")

#include <Windows.h>
#include <D3D11.h>
#include <D3DX11.h>
#include <D3DX10.h>
#include <gdiplus.h>
#include <string>

using namespace Gdiplus;
using namespace std;

namespace D3DProject1
{
	UINT windowStyle = WS_OVERLAPPEDWINDOW;
	HWND hMainWindow;
	HINSTANCE hCurrentInstance;
	IDXGISwapChain* swapchain;
	ID3D11RenderTargetView* backbuffer;
	ID3D11Device* dev;
	ID3D11DeviceContext* devcon;
	ID3D10Blob* vsBlob;
	ID3D10Blob* psBlob;
	ID3D11VertexShader* vs;
	ID3D11PixelShader* ps;
	ID3D11Buffer* vertexBuffer;
	ID3D11InputLayout *vertexBufferLayout;
	int viewportWidth = 800;
	int viewportHeight = 600;
	wstring shadersFile = L"Shaders.shader";

	wchar_t* W(wstring str)
	{
		wchar_t* result = new wchar_t[str.size()];
		wcscpy(result, str.c_str());
		return result;
	}

	char* S(string str)
	{
		char* result = new char[str.size()];
		strcpy(result, str.c_str());
		return result;
	}

	struct Vertex
	{
		float X, Y, Z;
		D3DXCOLOR Color;
	};

	D3D11_INPUT_ELEMENT_DESC VertexIED[] =
	{
		{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
		{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }
	};

	void CreateWC(wstring name, WNDPROC OnMessage)
	{
		WNDCLASSEX wc;
		ZeroMemory(&wc, sizeof(wc));

		wc.cbSize = sizeof(WNDCLASSEX);
		wc.style = CS_HREDRAW | CS_VREDRAW;
		wc.lpfnWndProc = OnMessage;
		wc.hInstance = hCurrentInstance;
		wc.hCursor = LoadCursor(NULL, IDC_ARROW);
		wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
		wc.lpszClassName = W(name);

		RegisterClassEx(&wc);
	}

	Size AdjustWndSzToViewportSz(int viewportWidth, int viewportHeight, UINT wndStyle = windowStyle)
	{
		RECT wr = { 0, 0, viewportWidth, viewportHeight };
		AdjustWindowRect(&wr, wndStyle, FALSE);
		return Size(wr.right - wr.left, wr.bottom - wr.top);
	}

	DXGI_SWAP_CHAIN_DESC CreateSCD(HWND hWnd, int width, int height)
	{
		DXGI_SWAP_CHAIN_DESC scd;
		ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));

		scd.BufferCount = 1;
		scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
		scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
		scd.BufferDesc.Width = width;
		scd.BufferDesc.Height = height;
		scd.OutputWindow = hWnd;
		scd.SampleDesc.Count = 4;
		scd.Windowed = TRUE;
		scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;

		return scd;
	}

	void InitD3DDeviceAndSwapChain(DXGI_SWAP_CHAIN_DESC& scd, IDXGISwapChain*& sc, ID3D11Device*& dev, ID3D11DeviceContext*& devCon)
	{
		D3D11CreateDeviceAndSwapChain
		(
			NULL,
			D3D_DRIVER_TYPE_HARDWARE,
			NULL,
			NULL,
			NULL,
			NULL,
			D3D11_SDK_VERSION,
			&scd,
			&swapchain,
			&dev,
			NULL,
			&devcon
		);
	}

	D3D11_VIEWPORT CreateViewport(int width, int height)
	{
		D3D11_VIEWPORT viewport;
		ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));

		viewport.TopLeftX = 0;
		viewport.TopLeftY = 0;
		viewport.Width = width;
		viewport.Height = height;

		return viewport;
	}

	void SetRenderTarget(ID3D11RenderTargetView*& renderTarget)
	{
		ID3D11Texture2D* pBackBuffer;
		swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&pBackBuffer);
		dev->CreateRenderTargetView(pBackBuffer, NULL, &renderTarget);
		devcon->OMSetRenderTargets(1, &renderTarget, NULL);
		pBackBuffer->Release();
	}

	void ClearRenderTarget(ID3D11RenderTargetView*& renderTarget)
	{
		devcon->ClearRenderTargetView(backbuffer, D3DXCOLOR(0.0f, 0.2f, 0.4f, 1.0f));
	}

	void SwapSCBuffers(IDXGISwapChain*& swapChain)
	{
		swapChain->Present(0, 0);
	}

	ID3D10Blob*& LoadVertexShader(wstring filename, string shaderName, string version, ID3D11VertexShader*& shader)
	{
		ID3D10Blob* vsBlob;
		D3DX11CompileFromFile(W(filename), 0, 0, S(shaderName), S(version), 0, 0, 0, &vsBlob, 0, 0);
		dev->CreateVertexShader(vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(), NULL, &shader);
		return vsBlob;
	}

	ID3D10Blob*& LoadPixelShader(wstring filename, string shaderName, string version, ID3D11PixelShader*& shader)
	{
		ID3D10Blob* psBlob;
		D3DX11CompileFromFile(W(filename), 0, 0, S(shaderName), S(version), 0, 0, 0, &psBlob, 0, 0);
		dev->CreatePixelShader(psBlob->GetBufferPointer(), psBlob->GetBufferSize(), NULL, &shader);
		return psBlob;
	}

	void InitRenderingPipeline()
	{
		vsBlob = LoadVertexShader(shadersFile, "VShader", "vs_4_0", vs);
		psBlob = LoadPixelShader(shadersFile, "PShader", "ps_4_0", ps);
		devcon->VSSetShader(vs, 0, 0);
		devcon->PSSetShader(ps, 0, 0);
	}

	D3D11_BUFFER_DESC CreateBD(int vertexCount)
	{
		D3D11_BUFFER_DESC bd;
		ZeroMemory(&bd, sizeof(bd));

		bd.Usage = D3D11_USAGE_DYNAMIC;
		bd.ByteWidth = sizeof(Vertex) * vertexCount;
		bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
		bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;

		return bd;
	}

	void CreateVertexBuffer(ID3D11Buffer*& buffer, int size)
	{
		auto bd = CreateBD(size);
		dev->CreateBuffer(&bd, NULL, &buffer);
	}

	void WriteVertexBuffer(ID3D11Buffer*& buffer, Vertex* vertices)
	{
		D3D11_MAPPED_SUBRESOURCE ms;
		devcon->Map(buffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
		memcpy(ms.pData, buffer, sizeof(vertices));
		devcon->Unmap(buffer, NULL);
	}

	ID3D11InputLayout* CreateInputLayout(D3D11_INPUT_ELEMENT_DESC* ied, ID3D10Blob* vsBlob)
	{
		ID3D11InputLayout* layout;
		dev->CreateInputLayout(ied, 2, vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(), &layout);
		return layout;
	}

	void LoadGeometry()
	{
		Vertex vertices[]
		{
			{ 0.0f, 0.5f, 0.0f, D3DXCOLOR(1.0f, 0.0f, 0.0f, 1.0f) },
			{ 0.45f, -0.5, 0.0f, D3DXCOLOR(0.0f, 1.0f, 0.0f, 1.0f) },
			{ -0.45f, -0.5f, 0.0f, D3DXCOLOR(0.0f, 0.0f, 1.0f, 1.0f) }
		};

		CreateVertexBuffer(vertexBuffer, 3);
		WriteVertexBuffer(vertexBuffer, vertices);
		vertexBufferLayout = CreateInputLayout(VertexIED, vsBlob);
		devcon->IASetInputLayout(vertexBufferLayout);
	}

	void InitD3D(HWND hWnd = hMainWindow)
	{
		auto scd = CreateSCD(hWnd, viewportWidth, viewportHeight);
		InitD3DDeviceAndSwapChain(scd, swapchain, dev, devcon);
		SetRenderTarget(backbuffer);
		auto viewport = CreateViewport(viewportWidth, viewportHeight);
		devcon->RSSetViewports(1, &viewport);
		InitRenderingPipeline();
		LoadGeometry();
	}

	void RenderFrame()
	{
		UINT stride = sizeof(Vertex);
		UINT offset = 0;
		devcon->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);

		// select which primtive type we are using
		devcon->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

		// draw the vertex buffer to the back buffer
		devcon->Draw(3, 0);

	}

	void ReleaseD3D()
	{
		vs->Release();
		ps->Release();
		swapchain->SetFullscreenState(FALSE, NULL);
		swapchain->Release();
		backbuffer->Release();
		dev->Release();
		devcon->Release();
	}

	LRESULT CALLBACK OnMessage(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
	{
		switch (message)
		{
			case WM_DESTROY:
				ReleaseD3D();
				ExitProcess(0);
				break;
		}
		return DefWindowProc(hWnd, message, wParam, lParam);
	}

	HWND CreateWnd(int width, int height, wstring title, UINT wndStyle = windowStyle)
	{
		CreateWC(title, OnMessage);
		HWND hWnd = CreateWindow
		(
			W(title),
			W(title),
			wndStyle,
			300,
			300,
			width,
			height,
			NULL,
			NULL,
			hCurrentInstance,
			NULL
		);
		ShowWindow(hWnd, SW_RESTORE);
		return hWnd;
	}

	void InitMessageLoop()
	{
		MSG msg;
		while (true)
		{
			if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
			else
			{
				ClearRenderTarget(backbuffer);
				RenderFrame();
				SwapSCBuffers(swapchain);
			}
		}
	}

	int WinMain(HINSTANCE hInstance, string cmdLine, int showCmd)
	{
		hCurrentInstance = hInstance;
		Size wndSz = AdjustWndSzToViewportSz(viewportWidth, viewportHeight);
		hMainWindow = CreateWnd(wndSz.Width, wndSz.Height, L"D3DProject1 Main Window");
		InitD3D(hMainWindow);
		InitMessageLoop();
		return 0;
	}
}

int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR cmdLine, int showCmd)
{
	return D3DProject1::WinMain(hInstance, cmdLine, showCmd);
}