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

using namespace Microsoft::WRL;

ComPtr<IDirect3D9> _d3d{ };
ComPtr<IDirect3DDevice9> _device{ };
ComPtr<IDirect3DVertexBuffer9> _vertexBuffer{ };
ComPtr<IDirect3DIndexBuffer9> _indexBuffer{ };
ComPtr<IDirect3DVertexDeclaration9> _vertexDecl{ };
ComPtr<IDirect3DVertexShader9> _vertexShader{ };
ComPtr<IDirect3DPixelShader9> _pixelShader{ };
ComPtr<ID3DXConstantTable> _vertexTable{ };
D3DXMATRIX _worldMatrix{ };
D3DXMATRIX _rotationMatrix{ };

bool _running{ false };

template <typename T>
unsigned int GetByteSize(const std::vector<T>& vec) {
	return sizeof(vec[0]) * vec.size();
}

struct VStruct {
	float x, y, z;
	D3DCOLOR color;
};


bool SetupTransform() {
	D3DXMatrixIdentity(&_worldMatrix);
	D3DXMatrixIdentity(&_rotationMatrix);
	
	D3DXMATRIX scaling{ };
	D3DXMatrixScaling(&scaling, 10, 10, 1);

	D3DXMatrixMultiply(&_worldMatrix, &scaling, &_rotationMatrix);
	HRESULT result = _vertexTable->SetMatrix(_device.Get(), "worldMatrix", &_worldMatrix);
	if (FAILED(result))
		return false;

	D3DXMATRIX view{ };
	D3DXMatrixLookAtLH(&view, &D3DXVECTOR3{ 0.0f, 0.0f, -20.0f }, &D3DXVECTOR3{ 0.0f, 0.0f, 0.0f }, &D3DXVECTOR3{ 0.0f, 1.0f, 0.0f });
	result = _vertexTable->SetMatrix(_device.Get(), "viewMatrix", &view);
	if (FAILED(result))
		return false;

	D3DXMATRIX projection{ };
	D3DXMatrixPerspectiveFovLH(&projection, D3DXToRadian(60.0f), 1024.0f / 768.0f, 0.0f, 100.0f);
	result = _vertexTable->SetMatrix(_device.Get(), "projectionMatrix", &projection);
	if (FAILED(result))
		return false;

	D3DXMatrixRotationY(&_rotationMatrix, D3DXToRadian(0.5f));

	return true;
}

IDirect3DVertexBuffer9* CreateVertexBuffer(const std::vector<VStruct>& vertices) {
	IDirect3DVertexBuffer9* buffer{ };
	HRESULT result{ };
	
	result = _device->CreateVertexBuffer(GetByteSize(vertices), 0, 0, D3DPOOL_DEFAULT, &buffer, nullptr); 
	if (FAILED(result))
		return nullptr;

	void* data{ };
	result = buffer->Lock(0, GetByteSize(vertices), &data, 0);     
	if (FAILED(result))
		return nullptr;

	memcpy(data, vertices.data(), GetByteSize(vertices));
	buffer->Unlock();

	return buffer;
}

IDirect3DIndexBuffer9* CreateIndexBuffer(std::vector<unsigned int>& indices) {
	IDirect3DIndexBuffer9* buffer{ };
	HRESULT result{ };
	
	result = _device->CreateIndexBuffer(GetByteSize(indices), 0, D3DFMT_INDEX32, D3DPOOL_DEFAULT, &buffer, nullptr);
	if (FAILED(result))
		return nullptr;

	void* data{ };
	result = buffer->Lock(0, GetByteSize(indices), &data, 0);
	if (FAILED(result))
		return nullptr;

	memcpy(data, indices.data(), GetByteSize(indices));
	buffer->Unlock();

	return buffer;
}

bool InitD3D(HWND hWnd) {
	RECT clientRect{ };
	GetClientRect(hWnd, &clientRect);

	_d3d = Direct3DCreate9(D3D_SDK_VERSION);

	D3DDISPLAYMODE displayMode{ };
	_d3d->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &displayMode);

	D3DPRESENT_PARAMETERS pp{ };
	pp.BackBufferWidth = clientRect.right;
	pp.BackBufferHeight = clientRect.bottom;
	pp.BackBufferFormat = displayMode.Format;
	pp.BackBufferCount = 1;                
	pp.SwapEffect = D3DSWAPEFFECT_DISCARD; 
	pp.hDeviceWindow = hWnd;              
	pp.Windowed = true;                    
	pp.Flags = 0;                    

	HRESULT result{ };
	result = _d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING, &pp, &_device);
	if (FAILED(result))
		return false;

	D3DVIEWPORT9 viewport{ };
	viewport.X = 0;      
	viewport.Y = 0;   
	viewport.Width = clientRect.right; 
	viewport.Height = clientRect.bottom;
	viewport.MinZ = 0.0f; 
	viewport.MaxZ = 100.0f; 

	result = _device->SetViewport(&viewport);
	if (FAILED(result))
		return false;

	return true;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
	switch (msg) {
		case WM_DESTROY:
			_running = false;
			PostQuitMessage(0);
			break;
	}
	return DefWindowProc(hWnd, msg, wParam, lParam);
}

int WINAPI WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPSTR lpCmdLine, _In_ int nCmdShow) {
	WNDCLASSEX wndEx{ };
	wndEx.cbSize = sizeof(WNDCLASSEX);
	wndEx.style = CS_VREDRAW | CS_HREDRAW;
	wndEx.lpfnWndProc = WndProc;
	wndEx.cbClsExtra = 0;
	wndEx.cbWndExtra = 0;
	wndEx.hInstance = hInstance;
	wndEx.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
	wndEx.hCursor = LoadCursor(nullptr, IDC_ARROW);
	wndEx.hbrBackground = (HBRUSH)COLOR_WINDOW;
	wndEx.lpszMenuName = nullptr;
	wndEx.lpszClassName = "DirectXClass";
	wndEx.hIconSm = nullptr;

	RegisterClassEx(&wndEx);

	HWND hWnd{ nullptr };
	hWnd = CreateWindow("DirectXClass", "directx window", WS_OVERLAPPEDWINDOW, 50, 50, 1024, 768, nullptr, nullptr, hInstance, nullptr);

	if (!hWnd)
		return -1;

	ShowWindow(hWnd, nCmdShow);
	UpdateWindow(hWnd);

	_running = true;

	if (!InitD3D(hWnd))
		return -1;

	std::vector<VStruct> vertices{
		VStruct{ -1.0f, -1.0f, 1.0f, D3DXCOLOR{ 1.0f, 0.0f, 0.0f, 1.0f } },
		VStruct{ -1.0f,  1.0f, 1.0f, D3DXCOLOR{ 0.0f, 1.0f, 0.0f, 1.0f } },
		VStruct{  1.0f,  1.0f, 1.0f, D3DXCOLOR{ 0.0f, 0.0f, 1.0f, 1.0f } },
		VStruct{  1.0f, -1.0f, 1.0f, D3DXCOLOR{ 1.0f, 1.0f, 0.0f, 1.0f } }
	};

	std::vector<unsigned int> indices{
		0, 1, 2,
		0, 2, 3
	};

	if (!(_vertexBuffer = CreateVertexBuffer(vertices)))
		return -1;

	if (!(_indexBuffer = CreateIndexBuffer(indices)))
		return -1;

	HRESULT result = _device->SetStreamSource(0, _vertexBuffer.Get(), 0, sizeof(VStruct));
	if (FAILED(result))
		return -1;

	result = _device->SetIndices(_indexBuffer.Get());
	if (FAILED(result))
		return -1;

	std::vector<D3DVERTEXELEMENT9> vertexDecl{
		{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
		{ 0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
		D3DDECL_END()
	};

	result = _device->CreateVertexDeclaration(vertexDecl.data(), &_vertexDecl);
	if (FAILED(result))
		return -1;

	_device->SetVertexDeclaration(_vertexDecl.Get());

	D3DCAPS9 deviceCaps{ };
	_device->GetDeviceCaps(&deviceCaps);

	if (deviceCaps.VertexShaderVersion < D3DVS_VERSION(3, 0))
		return -1;

	if (deviceCaps.PixelShaderVersion < D3DPS_VERSION(3, 0))
		return -1;
	
	ID3DXBuffer* vertexShaderBuffer{ };
	ID3DXBuffer* pixelShaderBuffer{ };

	result = D3DXCompileShaderFromFile("vertex.hlsl", nullptr, nullptr, "main", "vs_3_0", 0, &vertexShaderBuffer, nullptr, &_vertexTable);
	if (FAILED(result))
		return -1;

	result = D3DXCompileShaderFromFile("pixel.hlsl", nullptr, nullptr, "main", "ps_3_0", 0, &pixelShaderBuffer, nullptr, nullptr);
	if (FAILED(result))
		return -1;

	result = _device->CreateVertexShader((DWORD*)vertexShaderBuffer->GetBufferPointer(), &_vertexShader);
	if (FAILED(result))
		return -1;
	
	result = _device->CreatePixelShader((DWORD*)pixelShaderBuffer->GetBufferPointer(), &_pixelShader);
	if (FAILED(result))
		return -1;

	vertexShaderBuffer->Release();
	pixelShaderBuffer->Release();

	_device->SetVertexShader(_vertexShader.Get());
	_device->SetPixelShader(_pixelShader.Get());

	if (!SetupTransform())
		return -1;

	_device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);

	MSG msg{ };
	while (_running) {
		while (PeekMessage(&msg, hWnd, 0, 0, PM_REMOVE)) {
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		_device->Clear(0, nullptr, D3DCLEAR_TARGET, D3DXCOLOR{ 0.0f, 0.0f, 0.0f, 1.0f }, 0.0f, 0);   

		_device->BeginScene();
		_device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, indices.size(), 0, 2);
		_device->EndScene();

		_device->Present(nullptr, nullptr, nullptr, nullptr);

		D3DXMatrixMultiply(&_worldMatrix, &_worldMatrix, &_rotationMatrix);
		_vertexTable->SetMatrix(_device.Get(), "worldMatrix", &_worldMatrix);
	}

	return 0;
}