#include "ShadowMapManager.h"
#include "RenderTexture.h"
#include "RenderData.h"
#include "Renderer.h"
#include "ShelfPacker.h"
#include "Formats.hpp"
#include "IRenderContext.h"

#include "Core/Name.h"
#include "Core/SObject.h"
#include "Core/GarbageCollection.h"
#include "Core/Logger.h"

#include <algorithm>

namespace sh::render
{
	ShadowMapManager::ShadowMapManager() = default;
	ShadowMapManager::~ShadowMapManager()
	{
		Clear();
	}

	SH_RENDER_API void ShadowMapManager::Init(IRenderContext& ctx, uint32_t atlasSize)
	{
		this->ctx = &ctx;
		this->atlasSize = atlasSize;
		packer = std::make_unique<ShelfPacker>(static_cast<int>(atlasSize), static_cast<int>(atlasSize), 0);

		renderData.tag = core::Name{ "Depth" };
		renderData.priority = 1000; // 다른 패스보다 먼저 실행되도록
	}

	SH_RENDER_API void ShadowMapManager::Clear()
	{
		if (atlas != nullptr)
		{
			core::GarbageCollection::GetInstance()->RemoveRootSet(atlas);
			atlas = nullptr;
		}
		casters.clear();
		casterSlots.clear();
		casterLightSpace.clear();
		renderData = RenderData{};
		packer.reset();
		ctx = nullptr;
	}

	void ShadowMapManager::EnsureAtlas()
	{
		if (atlas != nullptr)
			return;
		if (ctx == nullptr)
		{
			SH_ERROR("ShadowMapManager: context is not initialized");
			return;
		}
		atlas = core::SObject::Create<RenderTexture>(TextureFormat::None, TextureFormat::D32, false);
		atlas->SetSize(atlasSize, atlasSize);
		atlas->Build(*ctx);
		atlas->SetName("ShadowAtlas");
		// 매니저는 SObject가 아니므로 GC가 회수하지 않도록 루트셋에 등록
		core::GarbageCollection::GetInstance()->SetRootSet(atlas);
	}

	SH_RENDER_API void ShadowMapManager::Register(IShadowCaster& caster)
	{
		if (std::find(casters.begin(), casters.end(), &caster) != casters.end())
			return;
		casters.push_back(&caster);
	}

	SH_RENDER_API void ShadowMapManager::Unregister(IShadowCaster& caster)
	{
		casters.erase(std::remove(casters.begin(), casters.end(), &caster), casters.end());
		casterSlots.erase(&caster);
		casterLightSpace.erase(&caster);
	}

	SH_RENDER_API void ShadowMapManager::Submit(Renderer& renderer)
	{
		if (casters.empty())
			return;

		EnsureAtlas();
		if (atlas == nullptr || packer == nullptr)
			return;

		packer->Reset();
		casterSlots.clear();
		casterLightSpace.clear();

		renderData.renderViewers.clear();
		renderData.SetRenderTarget(atlas);
		renderData.renderViewers.reserve(casters.size());

		for (const IShadowCaster* caster : casters)
		{
			if (caster == nullptr)
				continue;

			const uint32_t res = caster->GetShadowMapResolution();
			if (res == 0)
				continue;

			int x = 0, y = 0;
			if (!packer->Alloc(static_cast<int>(res), static_cast<int>(res), x, y))
			{
				SH_ERROR_FORMAT("ShadowMapManager: out of atlas space (atlas {}, requested {})",
					atlasSize, res);
				continue;
			}

			Slot slot{};
			slot.uvOffset = glm::vec2{ static_cast<float>(x) / atlasSize, static_cast<float>(y) / atlasSize };
			slot.uvSize = glm::vec2{ static_cast<float>(res) / atlasSize, static_cast<float>(res) / atlasSize };
			slot.valid = true;

			const glm::mat4 view = caster->GetShadowViewMatrix();
			const glm::mat4 proj = caster->GetShadowProjMatrix();

			casterSlots.emplace(caster, slot);
			casterLightSpace.emplace(caster, proj * view);

			RenderViewer viewer{};
			viewer.viewMatrix = view;
			viewer.projMatrix = proj;
			viewer.pos = caster->GetShadowPos();
			viewer.to = caster->GetShadowLookAt();
			viewer.viewportRect = glm::uvec4{ atlasSize * slot.uvOffset.x, atlasSize * slot.uvOffset.y, atlasSize * slot.uvSize.x, atlasSize * slot.uvSize.y };
			viewer.viewportScissor = viewer.viewportRect;
			renderData.renderViewers.push_back(viewer);
		}

		if (renderData.renderViewers.empty())
			return;

		renderer.PushRenderData(renderData);
	}

	SH_RENDER_API auto ShadowMapManager::GetSlot(const IShadowCaster& caster) const -> Slot
	{
		auto it = casterSlots.find(&caster);
		if (it == casterSlots.end())
			return Slot{};
		return it->second;
	}

	SH_RENDER_API auto ShadowMapManager::GetLightSpaceMatrix(const IShadowCaster& caster) const -> glm::mat4
	{
		auto it = casterLightSpace.find(&caster);
		if (it == casterLightSpace.end())
			return glm::mat4{ 1.f };
		return it->second;
	}
}//namespace