#ifndef DXD3D
#define DXD3D

#include <windows.h>
#include <d3d10.h>
#include <d3dx10.h>

#include "dxGeometry.h"

#include <vector>

//Macros for releasing objects safely
#define SAFE_DELETE(p) { if (p) { delete (p); (p)=NULL; } }
#define SAFE_DELETE_SHUTDOWN(p) { if (p) { (p)->shutDown(); delete(p); (p)=NULL; } }
#define RETURN_FALSE_OBJECT(p) { if (!p) { return false; } }

/**************************************************************************************
* dxD3D
* Simon GL Jordan 

* Description:
*	Initialises DirectX10 and resources
*   Stands as the bare minimum for a project to work, can be expanded or manipulated to
*   meet the projects needs
*	
* Note:
* I tried to retain structure of the frame work of DirectX10 which is defined in dxSystem::initialise()
* Create device -> Input assembly stage -> Rasterizer stage setup -> Output merger stage
*
* Use:
*	Begin() and End() are called in the render() function inside dxSystem to start and stop
*	rendering of data
*
* Future Implementations:
* 1.A shader loader could be extracted from loadShadersAndCreateInputLayouts()
* 2.Implement the camera to set up matrices and render scene
*
***************************************************************************************/

class dxD3D
{
private:
	HWND*				hWnd;

	IDXGISwapChain*				  m_swapChain;
	ID3D10Device*				  m_pD3DDevice;
	ID3D10RenderTargetView*		  m_renderTargetView;
	ID3D10Texture2D*			  m_depthStencilBuffer;
	ID3D10DepthStencilState*	  m_depthStencilState;
	ID3D10DepthStencilView*		  m_depthStencilView;
	ID3D10RasterizerState*		  m_rasterState;

	ID3D10Texture2D*			  pBackBuffer;
	D3D10_TEXTURE2D_DESC		  descDepth;
	D3D10_DEPTH_STENCIL_VIEW_DESC descDSV;
	D3D10_DEPTH_STENCIL_DESC	  depthStencilDesc;

	ID3D10EffectMatrixVariable*	  pViewMatrixEffectVariable;
	ID3D10EffectMatrixVariable*   pProjectionMatrixEffectVariable;
	ID3D10EffectMatrixVariable*   pWorldMatrixEffectVariable;
	
	ID3D10InputLayout*			  pVertexLayout;
	ID3D10Effect*				  pBasicEffect;
	ID3D10EffectTechnique*		  pBasicTechnique;

	D3D10_RASTERIZER_DESC rasterDesc;
	ID3D10RasterizerState* pRS;

	DXGI_SWAP_CHAIN_DESC swapChainDesc;

	D3D10_TECHNIQUE_DESC		techDesc;

public:
	dxD3D();
	dxD3D(const dxD3D&);

	~dxD3D();

	bool createSwapChainAndDevice( UINT width, UINT height);
	bool loadShadersAndCreateInputLayouts();
	void createViewports( UINT width, UINT height );
	bool initRasterizerState(){
		bool result;

		// Setup the raster description which will determine how and what polygons will be drawn.

		rasterDesc.AntialiasedLineEnable = false;
		rasterDesc.CullMode = D3D10_CULL_BACK;
		rasterDesc.DepthBias = 0;
		rasterDesc.DepthBiasClamp = 0.0f;
		rasterDesc.DepthClipEnable = true;
		rasterDesc.FillMode = D3D10_FILL_SOLID;
		rasterDesc.FrontCounterClockwise = false;
		rasterDesc.MultisampleEnable = false;
		rasterDesc.ScissorEnable = false;
		rasterDesc.SlopeScaledDepthBias = 0.0f;

		
		// Create the rasterizer state from the description we just filled out.
		result = m_pD3DDevice->CreateRasterizerState( &rasterDesc, &pRS);
		if(FAILED(result))
		{
			MessageBox(NULL, L"Failed to create razterizer state", NULL, NULL);
			return false;
		}

		m_pD3DDevice->RSSetState(pRS);

		return true;
	}//Inline for greater speed


	bool createRenderTargetsAndDepthBuffer( UINT width, UINT height );

	void beginScene(float red, float green, float blue, float alpha){
		float colour[4];


		// Setup the color to clear the buffer to.
		colour[0] = red;
		colour[1] = green;
		colour[2] = blue;
		colour[3] = alpha;

		// Clear the back buffer.
		m_pD3DDevice->ClearRenderTargetView(m_renderTargetView, colour);

		// Clear the depth buffer.
		m_pD3DDevice->ClearDepthStencilView(m_depthStencilView, D3D10_CLEAR_DEPTH, 1.0f, 0);
	}
	void endScene(){
		// Present as fast as possible.
		m_swapChain->Present(0, 0);
	}

	void shutDown();
};

dxD3D::dxD3D(): m_pD3DDevice(NULL),
				m_swapChain(NULL),
				m_renderTargetView(NULL),
				m_depthStencilBuffer(0),
				m_depthStencilState(0),
				m_depthStencilView(0),
				m_rasterState(0)
{}
dxD3D::dxD3D(const dxD3D& other)
{}

dxD3D::~dxD3D()
{}



bool dxD3D::createSwapChainAndDevice( UINT width, UINT height )
{
	HRESULT result;

	//Set up DX swap chain
	//--------------------------------------------------------------

	//set buffer dimensions and format
	// Initialize the swap chain description.
	ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));

	// Set to a single back buffer.
	swapChainDesc.BufferCount = 1;

	// Set the width and height of the back buffer.
	swapChainDesc.BufferDesc.Width = width;
	swapChainDesc.BufferDesc.Height = height;

	// Set regular 32-bit surface for the back buffer.
	swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;

	//set refresh rate
	swapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
	swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;

	// Set the usage of the back buffer.
    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;

	// Turn multisampling off.
	swapChainDesc.SampleDesc.Count = 1;
	swapChainDesc.SampleDesc.Quality = 0;

	// Set the handle for the window to render to.
    swapChainDesc.OutputWindow = *hWnd;

	// Set the scan line ordering and scaling to unspecified.
	swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
	swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;

	// Discard the back buffer contents after presenting.
	swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;

	// Don't set the advanced flags.
	swapChainDesc.Flags = 0;
	if(FAILED(result))
	{
		MessageBox(NULL, L"Failed", NULL, NULL);
		return false;
	}

	//Create the D3D device
	//--------------------------------------------------------------
	result = D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, 
		&swapChainDesc, &m_swapChain, &m_pD3DDevice);
	if(FAILED(result))
	{
		MessageBox(NULL, L"Failed to create the D3D device", NULL, NULL);
		return false;
	}

	return true;
}

bool dxD3D::createRenderTargetsAndDepthBuffer(UINT width, UINT height)
{
	HRESULT result;

	result = m_swapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&pBackBuffer);
	if(FAILED(result))
	{
		MessageBox(NULL, L"Failed to get the buffer", NULL, NULL);
		return false;
	}

	// Create the render target view with the back buffer pointer.
	result = m_pD3DDevice->CreateRenderTargetView(pBackBuffer, NULL, &m_renderTargetView);
	if(FAILED(result))
	{
		MessageBox(NULL, L"Failed to create the render target view", NULL, NULL);
		return false;
	}

	pBackBuffer->Release();
	pBackBuffer = 0;

	descDepth.Width = width;
	descDepth.Height = height;
	descDepth.MipLevels = 1;
	descDepth.ArraySize = 1;
	descDepth.Format = DXGI_FORMAT_D32_FLOAT;
	descDepth.SampleDesc.Count = 1;
	descDepth.SampleDesc.Quality = 0;
	descDepth.Usage = D3D10_USAGE_DEFAULT;
	descDepth.BindFlags = D3D10_BIND_DEPTH_STENCIL;
	descDepth.CPUAccessFlags = 0;
	descDepth.MiscFlags = 0;   
	
	// Create the texture for the depth buffer using the filled out description.
	result = m_pD3DDevice->CreateTexture2D(&descDepth, NULL, &m_depthStencilBuffer);
	if(FAILED(result))
	{
		return false;
		MessageBox(NULL, L"Failed to create the texture for the depth buffer", NULL, NULL);
	}

	// Initialize the description of the stencil state.
	ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));

	// Set up the description of the stencil state.
	depthStencilDesc.DepthEnable = true;
	depthStencilDesc.DepthWriteMask = D3D10_DEPTH_WRITE_MASK_ALL;
	depthStencilDesc.DepthFunc = D3D10_COMPARISON_LESS;

	depthStencilDesc.StencilEnable = true;
	depthStencilDesc.StencilReadMask = 0xFF;
	depthStencilDesc.StencilWriteMask = 0xFF;

	// Stencil operations if pixel is front-facing.
	depthStencilDesc.FrontFace.StencilFailOp = D3D10_STENCIL_OP_KEEP;
	depthStencilDesc.FrontFace.StencilDepthFailOp = D3D10_STENCIL_OP_INCR;
	depthStencilDesc.FrontFace.StencilPassOp = D3D10_STENCIL_OP_KEEP;
	depthStencilDesc.FrontFace.StencilFunc = D3D10_COMPARISON_ALWAYS;

	// Stencil operations if pixel is back-facing.
	depthStencilDesc.BackFace.StencilFailOp = D3D10_STENCIL_OP_KEEP;
	depthStencilDesc.BackFace.StencilDepthFailOp = D3D10_STENCIL_OP_DECR;
	depthStencilDesc.BackFace.StencilPassOp = D3D10_STENCIL_OP_KEEP;
	depthStencilDesc.BackFace.StencilFunc = D3D10_COMPARISON_ALWAYS;

	// Create the depth stencil state.
	result = m_pD3DDevice->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
	if(FAILED(result))
	{
		MessageBox(NULL, L"Failed to create the depth stencil state", NULL, NULL);
		return false;
	}

	// Initialise the depth stencil view.
	ZeroMemory(&descDepth, sizeof(descDepth));
	
	// Set up the depth stencil view description.
	descDSV.Format = descDepth.Format;
	descDSV.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D;
	descDSV.Texture2D.MipSlice = 0;

	// Create the depth stencil view.
	result = m_pD3DDevice->CreateDepthStencilView(m_depthStencilBuffer, &descDSV, &m_depthStencilView);
	if(FAILED(result))
	{
		MessageBox(NULL, L"Failed to create the depth stencil view", NULL, NULL);
		return false;
	}

	// Bind the render target view and depth stencil buffer to the output render pipeline.
	m_pD3DDevice->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);

	return true;
}

bool dxD3D::loadShadersAndCreateInputLayouts()
{
	//technique
	

	HRESULT result;

	result = D3DX10CreateEffectFromFile(L"./basicEffect.fx", 
		NULL, NULL, 
		"fx_4_0", 
		D3D10_SHADER_ENABLE_STRICTNESS, 
		0, 
		m_pD3DDevice, 
		NULL, 
		NULL, 
		&pBasicEffect, 
		NULL, 
		NULL	);
	if(!result)
	{
		MessageBox(NULL, L"Failed to load effect file", NULL, NULL);
		return false;
	}

	pBasicTechnique = pBasicEffect->GetTechniqueByName("render");
	if(!pBasicTechnique)
	{
		MessageBox(NULL, L"Failed to retrieve technique", NULL, NULL);
		return false;
	}	


	//create matrix effect pointers
	pViewMatrixEffectVariable = pBasicEffect->GetVariableByName( "View" )->AsMatrix();
	pProjectionMatrixEffectVariable = pBasicEffect->GetVariableByName( "Projection" )->AsMatrix();
	pWorldMatrixEffectVariable = pBasicEffect->GetVariableByName( "World" )->AsMatrix();	

	//create input layout
	D3D10_PASS_DESC PassDesc;
	pBasicTechnique->GetPassByIndex( 0 )->GetDesc( &PassDesc );


	// Create the input layout.
	result = m_pD3DDevice->CreateInputLayout( vertexInputLayout, 
		2, 
		PassDesc.pIAInputSignature,
		PassDesc.IAInputSignatureSize, 
		&pVertexLayout );
	if(FAILED(result))
	{
		MessageBox(NULL, L"Failed to create the input layout", NULL, NULL);
		return false;
	}

	// Set the input layout
	m_pD3DDevice->IASetInputLayout( pVertexLayout );

	//get technique description
	pBasicTechnique->GetDesc( &techDesc );

	return true;
}

void dxD3D::shutDown()
{
	// Before shutting down set to windowed mode or when you release the swap chain it will throw an exception.
	if(m_swapChain)
	{
		m_swapChain->SetFullscreenState(false, NULL);
	}

	if(m_rasterState)
	{
		m_rasterState->Release();
		m_rasterState = 0;
	}

	if(m_depthStencilView)
	{
		m_depthStencilView->Release();
		m_depthStencilView = 0;
	}

	if(m_depthStencilState)
	{
		m_depthStencilState->Release();
		m_depthStencilState = 0;
	}

	if(m_depthStencilBuffer)
	{
		m_depthStencilBuffer->Release();
		m_depthStencilBuffer = 0;
	}

	if(m_renderTargetView)
	{
		m_renderTargetView->Release();
		m_renderTargetView = 0;
	}

	if(m_swapChain)
	{
		m_swapChain->Release();
		m_swapChain = 0;
	}

	if(m_pD3DDevice)
	{
		m_pD3DDevice->Release();
		m_pD3DDevice = 0;
	}

}

#endif