#ifndef RENDERING_H
#define RENDERING_H

#include "interface.h"
#include "math3d.h"
#include "tier0/platform.h"
#include "tier1/utlbuffer.h"
#include "baseentity.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"

extern mat4 g_cameraView;


enum EImageFormat
{
	IMAGE_FORMAT_R8,
	IMAGE_FORMAT_R8G8,
	IMAGE_FORMAT_R8G8B8,
	IMAGE_FORMAT_R8G8B8A8,
	IMAGE_FORMAT_R16,
	IMAGE_FORMAT_R16G16,
	IMAGE_FORMAT_R16G16B16,
	IMAGE_FORMAT_R16G16B16A16,
	IMAGE_FORMAT_R32,
	IMAGE_FORMAT_R32G32,
	IMAGE_FORMAT_R32G32B32,
	IMAGE_FORMAT_R32G32B32A32,
	IMAGE_FORMAT_DEPTH,

	IMAGE_FORMAT_WINDOW,
};

enum EImageUsage
{
	IMAGE_USAGE_COLOR_ATTACHMENT = 0x1,
	IMAGE_USAGE_DEPTH_ATTACHMENT = 0x2,
	IMAGE_USAGE_STORAGE = 0x4,
};

enum EVertexFormat
{
	VERTEX_FORMAT_X16,
	VERTEX_FORMAT_X16Y16,
	VERTEX_FORMAT_X16Y16Z16,
	VERTEX_FORMAT_X16Y16Z16W16,
	VERTEX_FORMAT_X32,
	VERTEX_FORMAT_X32Y32,
	VERTEX_FORMAT_X32Y32Z32,
	VERTEX_FORMAT_X32Y32Z32W32,
};

enum EMSAAMode
{
	MSAA_MODE_DISABLED,
	MSAA_MODE_MIN,
	MSAA_MODE_MAX,
	MSAA_MODE_AVERAGE,
};

enum EDepthMode
{
	DEPTH_MODE_DISABLED,
	DEPTH_MODE_EQUAL,
	DEPTH_MODE_NOT_EQUAL,
	DEPTH_MODE_LESS,
	DEPTH_MODE_LESS_EQUAL,
	DEPTH_MODE_GREATER,
	DEPTH_MODE_GREATER_EQUAL,
};

enum EShaderInputType
{
	SHADER_INPUT_TYPE_STORAGE_BUFFER,
	SHADER_INPUT_TYPE_UNIFORM_BUFFER,
	SHADER_INPUT_TYPE_IMAGE,
	SHADER_INPUT_TYPE_TLAS,
	
	// All available textures are binded
	SHADER_INPUT_TYPE_TEXTURES,
};

enum EShaderType
{
	SHADER_TYPE_VERTEX,
	SHADER_TYPE_GEOMETRY,
	SHADER_TYPE_FRAGMENT,
	SHADER_TYPE_COMPUTE,
	SHADER_TYPE_RAY_GEN,
	SHADER_TYPE_CLOSEST_HIT,
	SHADER_TYPE_MISS,
	SHADER_TYPE_INTERSECTION,
	SHADER_TYPE_ANY_HIT,
};

enum EBarrierMemoryPermissions
{
	BARRIER_MEMORY_PERMISSIONS_NONE = 0x0,
	BARRIER_MEMORY_PERMISSIONS_VERTEX_BUFFER_READ = 0x1,
	BARRIER_MEMORY_PERMISSIONS_INDEX_BUFFER_READ = 0x2,
	BARRIER_MEMORY_PERMISSIONS_UNIFORM_BUFFER_READ = 0x4,
	BARRIER_MEMORY_PERMISSIONS_SHADER_READ = 0x8,
	BARRIER_MEMORY_PERMISSIONS_SHADER_WRITE = 0x10,
	BARRIER_MEMORY_PERMISSIONS_COLOR_READ = 0x20,
	BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE = 0x40,
	BARRIER_MEMORY_PERMISSIONS_DEPTH_READ = 0x80,
	BARRIER_MEMORY_PERMISSIONS_DEPTH_WRITE = 0x100,
	BARRIER_MEMORY_PERMISSIONS_COPY_READ = 0x200,
	BARRIER_MEMORY_PERMISSIONS_COPY_WRITE = 0x400,
	BARRIER_MEMORY_PERMISSIONS_BLIT_READ = 0x800,
	BARRIER_MEMORY_PERMISSIONS_BLIT_WRITE = 0x1000,
};
enum EBarrierStage
{
	BARRIER_STAGE_TOP = 0x1,
	BARRIER_STAGE_VERTEX_INPUT = 0x2,
	BARRIER_STAGE_VERTEX_SHADER = 0x4,
	BARRIER_STAGE_GEOMETRY_SHADER = 0x8,
	BARRIER_STAGE_FRAGMENT_SHADER = 0x10,
	BARRIER_STAGE_DEPTH_OUTPUT = 0x20,
	BARRIER_STAGE_COLOR_OUTPUT = 0x40,
	BARRIER_STAGE_COMPUTE_SHADER = 0x80,
	BARRIER_STAGE_RAY_TRACING_SHADER = 0x100,
	BARRIER_STAGE_BOTTOM = 0x200,
	BARRIER_STAGE_BLIT = 0x400,
	BARRIER_STAGE_COPY = 0x800,
	BARRIER_STAGE_IMAGE_OUPUT = 0x1000,
};

enum EAttachmentLoadMode
{
	ATTACHMENT_LOAD_MODE_DONT_CARE,
	ATTACHMENT_LOAD_MODE_CLEAR,
	ATTACHMENT_LOAD_MODE_LOAD,
};

enum EAttachmentStoreMode
{
	ATTACHMENT_STORE_MODE_DONT_CARE,
	ATTACHMENT_STORE_MODE_STORE,
};

enum EPipelineType
{
	PIPELINE_TYPE_RASTERIZATION,
	PIPELINE_TYPE_COMPUTE,
	PIPELINE_TYPE_RAY_TRACING,
};



interface IVideo 
{
public:
	static void Init();
	static void Deinit();
	static void CreatePipelines( void );
	static void Frame( float fDelta );
};

abstract_class IBuffer
{
public:
	virtual void *Map() = 0;
	virtual void Unmap() = 0;
};

typedef IBuffer IStorageBuffer;
typedef IBuffer IUniformBuffer;
typedef IBuffer IVertexBuffer;
typedef IBuffer IIndexBuffer;

abstract_class IImage
{
public:
	EImageFormat format;
};

//----------------------------------------------------------------------------
// Bottom level acceleration structure for ray tracing. 
//----------------------------------------------------------------------------
abstract_class IBLAS
{
public:
	virtual void Build() = 0;
	virtual void Update() = 0;
};



//----------------------------------------------------------------------------
// Bottom level acceleration structure with triangle geometry.
//----------------------------------------------------------------------------
abstract_class IBLASMesh: public IBLAS
{
public:
	virtual void SetMesh( IVertexBuffer *pVertex, IIndexBuffer *pIndex ) = 0;
};

//----------------------------------------------------------------------------
// Bottom level acceleration structure with AABB geometry.
//----------------------------------------------------------------------------
abstract_class IBLASAABB: public IBLAS
{
public:
	virtual void SetBoundaries( vec4 size );
};

//----------------------------------------------------------------------------
// Top level acceleration structure for handling worlds
//----------------------------------------------------------------------------
abstract_class ITLAS
{
public:
	virtual void AddInstance( IBLAS *pBLAS, mat4 matrix, uint32_t data ) = 0;
	virtual void ResetInstances() = 0;
};


struct ShaderInput_t
{
	EShaderInputType type;
	uint32_t binding;
};

struct Shader_t
{
	CUtlString szPath;
	EShaderType type;
};

abstract_class IPipeline
{
public:
	EPipelineType type;
	virtual void PushBindings() = 0;
	virtual void BindData( uint32_t binding, IBuffer *pBuffer, IImage* pImage) = 0;
};
typedef IPipeline IGraphicsPipeline;
typedef IPipeline IComputePipeline;
typedef IPipeline IRayTracingPipeline;



//----------------------------------------------------------------------------
// Texture handle
//----------------------------------------------------------------------------
abstract_class ITexture
{
public:
	const char *szName;
	uint32_t x;
	uint32_t y;
	uint32_t id;
};

//----------------------------------------------------------------------------
// Manages loaded textures
//----------------------------------------------------------------------------
interface ITextureManager
{
public:
	static uint32_t GetTextureID(ITexture *pTexture);
	static ITexture *LoadTexture( void *pData, uint32_t X, uint32_t Y, uint32_t numChannels );
	static ITexture *LoadTexture( const char *szName );
};

struct BufferBarrier_t
{
	uint32_t in;
	uint32_t out;
	IBuffer *pBuffer;
};
struct ImageBarrier_t
{
	uint32_t in;
	uint32_t out;
	IImage *pImage;
};

struct VertexAttribute_t
{
	uint32_t offset;
	uint32_t binding;
	EVertexFormat format;
};

struct RenderingColorAttachment_t
{
	IImage *pOutput;
	IImage *pTemporary;
	EAttachmentLoadMode loadMode;
	EAttachmentStoreMode storeMode;
	vec4 clearColor;
	EMSAAMode msaaMode;
};

struct RenderingDepthAttachment_t
{
	IImage *pOutput;
	IImage *pTemporary;
	EAttachmentLoadMode loadMode;
	EAttachmentStoreMode storeMode;
	float clearValue;
	EMSAAMode msaaMode;
};

abstract_class IRenderingPipelineStep
{
public:
	virtual void Init() = 0;
	virtual void Frame( float fDelta ) = 0;
	virtual void Deinit() = 0;
};

typedef IRenderingPipelineStep*(*CreateRenderStepFn)();
struct RenderingStep_t
{
	IRenderingPipelineStep *pPipeline;
	const char *szName;
};


//----------------------------------------------------------------------------
// Manages all buffers and pipelines.
// It is meant to be used in render pipelines
//----------------------------------------------------------------------------
interface IRenderer: public IInterface
{
public:

	virtual IStorageBuffer *CreateStorageBuffer( uint32_t uSize ) = 0;
	virtual IUniformBuffer *CreateUniformBuffer( uint32_t uSize ) = 0;
	virtual IVertexBuffer *CreateVertexBuffer( uint32_t uSize ) = 0;
	virtual IIndexBuffer *CreateIndexBuffer( uint32_t uSize ) = 0;
	virtual IImage *CreateImage( EImageFormat format, uint32_t usage, uint32_t nWidth, uint32_t nHeight, uint32_t nSamples = 1 ) = 0;

	virtual void DestroyBuffer( IBuffer *pBuffer ) = 0;
	virtual void DestroyImage( IImage *pImage ) = 0;

	virtual void SetConstants( uint32_t nSize, void *pData ) = 0;
	virtual void Barrier( uint32_t stageIn, uint32_t stageOut, CUtlVector<BufferBarrier_t> buffers, CUtlVector<ImageBarrier_t> images ) = 0;
	virtual void BindPipeline( IPipeline *pPipeline ) = 0;

	virtual void Begin( uint32_t nWidth, uint32_t nHeight, CUtlVector<RenderingColorAttachment_t> attachments, RenderingDepthAttachment_t depth ) = 0;
	virtual void ResetState() = 0;
	virtual void SetDepthMode( EDepthMode mode ) = 0;
	virtual void Draw( IVertexBuffer *pVertex, IIndexBuffer *pIndex ) = 0;
	virtual void End() = 0;
	
	virtual void Dispatch( uint32_t x, uint32_t y, uint32_t z ) = 0;
	virtual void TraceRays( uint32_t x, uint32_t y, uint32_t z ) = 0;

	virtual IGraphicsPipeline *CreateGraphicsPipeline(
		CUtlVector<Shader_t> shaders,
		CUtlVector<ShaderInput_t> inputs,
		uint32_t nConstantsSize,
		uint32_t nVertexSize,
		CUtlVector<VertexAttribute_t> vertexFormat,
		CUtlVector<EImageFormat> outputFormats,
		bool bDepth
	) = 0;
	virtual IComputePipeline *CreateComputePipeline(
		Shader_t szShader,
		CUtlVector<ShaderInput_t> inputs,
		uint32_t nConstantsSize
	) = 0;

	virtual IRayTracingPipeline *CreateRayTracingPipeline(
		CUtlVector<Shader_t> shaders,
		CUtlVector<ShaderInput_t> inputs,
		uint32_t nConstantsSize
	) = 0;
	
	virtual IBuffer *GetCameraMatrix() = 0;
	virtual IImage *GetOutputImage() = 0;

	CUtlVector<RenderingStep_t> m_StepPrepass;
	CUtlVector<RenderingStep_t> m_StepMeshRendering;
	CUtlVector<RenderingStep_t> m_StepShading;
	CUtlVector<RenderingStep_t> m_StepPostProcessing;
	CUtlVector<RenderingStep_t> m_StepUI;
};

IRenderer *Renderer();

extern char g_bConfigNotify;
extern uint32_t g_nWindowWidth;
extern uint32_t g_nWindowHeight;


class CRenderingStep
{
public:
	CRenderingStep();
	CRenderingStep(const char *szStepName, CreateRenderStepFn pfn);
};

class CPrepassRenderingStep: public CRenderingStep
{
public:
	CPrepassRenderingStep(const char *szStepName, CreateRenderStepFn pfn);
};
class CMeshRenderingStep: public CRenderingStep
{
public:
	CMeshRenderingStep(const char *szStepName, CreateRenderStepFn pfn);
};

class CShadingRenderingStep: public CRenderingStep
{
public:
	CShadingRenderingStep(const char *szStepName, CreateRenderStepFn pfn);
};

class CPostProcessingRenderingStep: public CRenderingStep
{
public:
	CPostProcessingRenderingStep(const char *szStepName, CreateRenderStepFn pfn);
};

class CUIRenderingStep: public CRenderingStep
{
public:
	CUIRenderingStep(const char *szStepName, CreateRenderStepFn pfn);
};

#define DECLARE_MESH_PREPASS_STAGE(class, name) \
IRenderingPipelineStep *__rendering_stage_##name() \
{ \
	return new class; \
}; \
CPrepassRenderingStep __renering_##name##_registry(#name, __rendering_stage_##name);
#define DECLARE_MESH_RENDERING_STAGE(class, name) \
IRenderingPipelineStep *__rendering_stage_##name() \
{ \
	return new class; \
}; \
CMeshRenderingStep __renering_##name##_registry(#name, __rendering_stage_##name);
#define DECLARE_MESH_SHADING_STAGE(class, name) \
IRenderingPipelineStep *__rendering_stage_##name() \
{ \
	return new class; \
}; \
CShadingRenderingStep __renering_##name##_registry(#name, __rendering_stage_##name);
#define DECLARE_POST_PROCESSING_STAGE(class, name) \
IRenderingPipelineStep *__rendering_stage_##name() \
{ \
	return new class; \
}; \
CPostProcessingRenderingStep __renering_##name##_registry(#name, __rendering_stage_##name);
#define DECLARE_UI_RENDERING_STAGE(class, name) \
IRenderingPipelineStep *__rendering_stage_##name() \
{ \
	return new class; \
}; \
CUIRenderingStep __renering_##name##_registry(#name, __rendering_stage_##name);

#endif