#include "vulkan_state.h"
#include "commands.h"

void CVkRenderCommandList::ResetRendering()
{
	/*
	for ( auto m: m_materials)
	{
		delete m.m_pCommandBuffer;
	}
	*/
	m_materials = {};
}

void CVkRenderCommandList::SetRenderTarget( uint32_t uIndex, IImage *pImage )
{
	SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
	VulkanRenderOutput_t *pOutput = FindOrCreateRenderOutput(uIndex);
	pOutput->m_stImage.m_eObjectType = FRAME_OBJECT_TYPE_SINGLE;
	pOutput->m_stImage.m_pSingle = pImage;
}

void CVkRenderCommandList::SetClearColor( uint32_t uIndex, float r, float g, float b, float a )
{
	SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
	VulkanRenderOutput_t *pOutput = FindOrCreateRenderOutput(uIndex);
	pOutput->m_fClearColor[0] = r;
	pOutput->m_fClearColor[1] = g;
	pOutput->m_fClearColor[2] = b;
	pOutput->m_fClearColor[3] = a;
}

void CVkRenderCommandList::SetDepthTarget( IImage *pDepth )
{
	SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
	m_depth.m_stImage.m_pSingle = pDepth;

}
void CVkRenderCommandList::SetClearDepth( float fVal)
{
	SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
	m_depth.m_fClearDepth = fVal;
}

void CVkRenderCommandList::SetRenderResolution( uint32_t iWidth, uint32_t iHeight )
{
	SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
	m_uWidth = iWidth;
	m_uHeight = iHeight;
}


void CVkRenderCommandList::SetScissors( uint32_t uX, uint32_t uY, uint32_t uWidth, uint32_t uHeight )
{
	SwitchRenderingStage(RENDERING_STAGE_RASTER);
}

void CVkRenderCommandList::SetViewport( uint32_t uX, uint32_t uY, uint32_t uWidth, uint32_t uHeight, float fMinDepth, float fMaxDepth )
{
	SwitchRenderingStage(RENDERING_STAGE_RASTER);
}





void CVkRenderCommandList::SetMaterial( IMaterial *pMaterial )
{
	SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
	bool bWasCreated = false;
	m_pCurrentMaterialBuffer = FindOrCreateMaterialCommandBuffer(pMaterial, &bWasCreated);
	if (bWasCreated)
	{
		m_pCurrentMaterialBuffer->Reset();
		CVkBeginCommand *pBeginCommand = CREATE_COMMAND(Begin);
		pBeginCommand->images = m_pOutput;
		pBeginCommand->nResolutionX = m_uWidth;
		pBeginCommand->nResolutionY = m_uHeight;
		pBeginCommand->stDepthImage = m_depth;
		for ( auto &i: pBeginCommand->images)
		{
			pBeginCommand->AddDependency(i.m_stImage.m_pSingle, DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE);
		}
		m_pCurrentMaterialBuffer->AddCommand(pBeginCommand);

		CVkSetShaderCommand *pSetShader = CREATE_COMMAND(SetShader);
		pSetShader->pShader = ((CVkMaterial*)pMaterial)->m_pVkShader;
		m_pCurrentMaterialBuffer->AddCommand(pSetShader);

		CVkSetShaderDataCommand *pSetShaderData = CREATE_COMMAND(SetShaderData);
		pSetShaderData->pShaderData = pMaterial;
		m_pCurrentMaterialBuffer->AddCommand(pSetShaderData);

		CVkSetScissorsCommand *pScissorsCommand = CREATE_COMMAND(SetScissors);
		pScissorsCommand->uWidth = m_uWidth;
		pScissorsCommand->uHeight = m_uHeight;
		m_pCurrentMaterialBuffer->AddCommand(pScissorsCommand);

		CVkSetViewportCommand *pViewportCommand = CREATE_COMMAND(SetViewport);
		pViewportCommand->fX = 0;
		pViewportCommand->fY = 0;
		pViewportCommand->fWidth = m_uWidth;
		pViewportCommand->fHeight = m_uHeight;
		pViewportCommand->fDepthMin = 0;
		pViewportCommand->fDepthMax = 1;
		m_pCurrentMaterialBuffer->AddCommand(pViewportCommand);
	}
}

void CVkRenderCommandList::SetVertexBuffer( uint32_t uBinding, IVertexBuffer *pBuffer )
{
	SwitchRenderingStage(RENDERING_STAGE_RASTER);
	CVkSetVertexBufferCommand *pCmd = CREATE_COMMAND(SetVertexBuffer);
	pCmd->uBinding = uBinding;
	pCmd->pBuffer = pBuffer;
	m_pCurrentMaterialBuffer->AddCommand(pCmd);
}

void CVkRenderCommandList::SetIndexBuffer( IVertexBuffer *pBuffer )
{
	SwitchRenderingStage(RENDERING_STAGE_RASTER);
}

void CVkRenderCommandList::DrawPrimitives( uint32_t nVertexCount, uint32_t nFirstVertex, uint32_t nInstanceCount, uint32_t nFirstInstance )
{
	SwitchRenderingStage(RENDERING_STAGE_RASTER);

	CVkDrawPrimitivesCommand *pCmd = CREATE_COMMAND(DrawPrimitives);
	pCmd->nVertexCount = nVertexCount;
	pCmd->nFirstVertex = nFirstVertex;
	pCmd->nInstanceCount = nInstanceCount;
	pCmd->nFirstInstance = nFirstInstance;
	m_pCurrentMaterialBuffer->AddCommand(pCmd);
}

void CVkRenderCommandList::DrawPrimitivesIndexed( uint32_t nIndexCount, uint32_t nFirstIndex, uint32_t nVertexOffset, uint32_t nInstanceCount, uint32_t nFirstInstance )
{
	SwitchRenderingStage(RENDERING_STAGE_RASTER);

}


void CVkRenderCommandList::ResolveImage( IImage *pOriginal, IImage *pResolved )
{
	SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);

}


void CVkRenderCommandList::StartRecording()
{
	ResetRendering();
}

void CVkRenderCommandList::EndRecording()
{
	for ( auto m: m_materials)
	{
		CVkEndCommand *pEndCommand = CREATE_COMMAND(End);
		m.m_pCommandBuffer->AddCommand(pEndCommand);
		m.m_pCommandBuffer->Render();
	}
}

void CVkRenderCommandList::Submit()
{
	for ( auto m: m_materials)
	{
		m.m_pCommandBuffer->Submit();
	}
}

void CVkRenderCommandList::SwitchRenderingStage( EVulkanRenderingStage eStage )
{

}

VulkanRenderOutput_t *CVkRenderCommandList::FindOrCreateRenderOutput( uint32_t uIndex )
{
	for ( auto &v: m_pOutput )
	{
		if (v.m_uIndex == uIndex)
			return &v;
	}

	VulkanRenderOutput_t output = {};
	output.m_uIndex = uIndex;
	m_pOutput.AppendTail(output);
	return &m_pOutput[m_pOutput.GetSize()-1];
}

IVkCommandBuffer *CVkRenderCommandList::FindOrCreateMaterialCommandBuffer( IMaterial *pMaterial, bool *pbWasCreated )
{
	for (auto &m: m_materials)
	{
		if (m.m_pMaterial == pMaterial)
		{
			if (pbWasCreated)
				*pbWasCreated = false;
			return m.m_pCommandBuffer;
		}
	}

	VulkanMaterialCommandBuffer_t mat;
	mat.m_pCommandBuffer = m_pCommandBufferManager->CreateCommandBuffer();
	mat.m_pMaterial = pMaterial;
	m_materials.AppendTail(mat);
	if (pbWasCreated)
		*pbWasCreated = true;
	return m_materials.GetLast().m_pCommandBuffer;
}