#include "ScriptableRenderPass.h"
#include "IRenderContext.h"
#include "Drawable.h"
#include "RenderTexture.h"
#include "MaterialData.h"

#include "Core/Logger.h"
#include "Core/Util.h"

namespace sh::render
{
	ScriptableRenderPass::ScriptableRenderPass(const core::Name& passName, RenderQueue renderQueue) :
		passName(passName),
		renderQueue(renderQueue)
	{
	}
	SH_RENDER_API auto ScriptableRenderPass::CreateRenderBatch(const core::Name& passName, const std::vector<Drawable*>& drawables) -> std::vector<RenderBatch>
	{
		std::vector<RenderBatch> groups;
		struct GroupKey
		{
			const Material* mat;
			Mesh::Topology topology;
			bool bSkinned;

			bool operator==(const GroupKey& other) const noexcept { return mat == other.mat && topology == other.topology && bSkinned == other.bSkinned; }
		};
		struct GroupKeyHash
		{
			std::size_t operator()(const GroupKey& k) const noexcept
			{
				const std::size_t hash0 = core::Util::CombineHash(std::hash<const Material*>{}(k.mat), std::hash<int>{}(static_cast<int>(k.topology)));
				const std::size_t hash1 = core::Util::CombineHash(hash0, std::hash<bool>{}(k.bSkinned));
				return hash1;
			}
		};
		std::unordered_map<GroupKey, std::size_t, GroupKeyHash> groupIndex;
		groupIndex.reserve(drawables.size());

		std::map<const Material*, bool> materialFilter;
		for (const Drawable* drawable : drawables)
		{
			if (!core::IsValid(drawable) || !drawable->CheckAssetValid())
				continue;

			const Material* const mat = drawable->GetMaterial();
			if (auto it = materialFilter.find(mat); it == materialFilter.end())
			{
				if (mat->GetShader()->GetShaderPasses(passName) == nullptr)
				{
					materialFilter.insert({ mat, false });
					continue;
				}
				materialFilter.insert({ mat, true });
			}
			else
			{
				if (!it->second)
					continue;
			}

			Mesh::Topology topology = drawable->GetTopology(core::ThreadType::Render);
			const bool bSkinned = drawable->IsSkinnedMesh();

			GroupKey key{ mat, topology, bSkinned };
			auto it = groupIndex.find(key);
			if (it == groupIndex.end())
			{
				RenderBatch group{};
				group.material = mat;
				group.topology = topology;
				group.bSkinned = bSkinned;
				group.drawables.push_back(drawable);

				groupIndex.emplace(key, groups.size());
				groups.push_back(std::move(group));
			}
			else
			{
				groups[it->second].drawables.push_back(drawable);
			}
		}
		return groups;
	}
	SH_RENDER_API void ScriptableRenderPass::Configure(const RenderData& renderData)
	{
		if (renderData.GetDrawablesPtr() != nullptr)
		{
			renderBatches = CreateRenderBatch(passName, *renderData.GetDrawablesPtr());
		}
		SetImageUsages(renderData);
	}
	SH_RENDER_API void ScriptableRenderPass::Record(CommandBuffer& cmd, const IRenderContext& ctx, const RenderData& renderData)
	{
		cmd.SetRenderData(renderData, true, true, true, true);
		if (renderData.GetDrawablesPtr() == nullptr)
			return;
		std::size_t viewerIdx = 0;
		for (const RenderViewer& viewer : renderData.renderViewers)
		{
			SetViewportScissor(cmd, ctx, viewer);
			for (const RenderBatch& batch : renderBatches)
				cmd.DrawMeshBatch(batch.drawables, passName, viewerIdx);
			++viewerIdx;
		}
		//ctx.GetRenderImpl().RecordCommand(cmd, passName, renderTarget, drawList, bStoreImage);
	}
	SH_RENDER_API void ScriptableRenderPass::SetImageUsages(const RenderData& renderData)
	{
		renderTextures.clear();

		SetRenderTargetImageUsages(renderData);

		if (renderData.GetDrawablesPtr() != nullptr)
			SetImageUsages(*renderData.GetDrawablesPtr());
	}
	SH_RENDER_API void ScriptableRenderPass::SetRenderTargetImageUsages(const RenderData& renderData)
	{
		for (const RenderTexture* target : renderData.GetRenderTargets())
		{
			if (target == nullptr)
			{
				renderTextures[nullptr] = ResourceUsage::ColorAttachment;
				continue;
			}

			renderTextures[target] = target->IsDepthTexture() ? ResourceUsage::DepthStencilAttachment : ResourceUsage::ColorAttachment;
		}
	}
	SH_RENDER_API void ScriptableRenderPass::SetImageUsages(const std::vector<Drawable*>& drawables)
	{
		for (const Drawable* drawable : drawables)
		{
			if (drawable == nullptr || !drawable->CheckAssetValid())
				continue;

			for (const MaterialData::CachedRT& cachedRT : IRenderThrMethod<MaterialData>::GetCachedRTs(drawable->GetMaterialData()))
			{
				if (cachedRT.rt.IsValid() && cachedRT.pass->GetLightingPassName() == passName)
					renderTextures[cachedRT.rt.Get()] = cachedRT.rt->IsDepthTexture() ? ResourceUsage::DepthStencilSampledRead : ResourceUsage::SampledRead;
			}
			const Material* const mat = drawable->GetMaterial();
			SetImageUsages(*mat);
		}
	}
	SH_RENDER_API void ScriptableRenderPass::SetImageUsages(const Material& mat)
	{
		for (const MaterialData::CachedRT& cachedRT : IRenderThrMethod<MaterialData>::GetCachedRTs(mat.GetMaterialData()))
		{
			if (cachedRT.rt.IsValid() && cachedRT.pass->GetLightingPassName() == passName)
				renderTextures[cachedRT.rt.Get()] = cachedRT.rt->IsDepthTexture() ? ResourceUsage::DepthStencilSampledRead : ResourceUsage::SampledRead;
		}
	}
	SH_RENDER_API void ScriptableRenderPass::SetViewportScissor(CommandBuffer& cmd, const IRenderContext& ctx, const RenderViewer& renderViewer)
	{
		cmd.SetViewport(renderViewer.viewportRect.x, renderViewer.viewportRect.y, renderViewer.viewportRect.z, renderViewer.viewportRect.w);
		cmd.SetScissor(renderViewer.viewportScissor.x, renderViewer.viewportScissor.y, renderViewer.viewportScissor.z, renderViewer.viewportScissor.w);
	}
}//namespace