#include "CScene.hpp"
#include "../Entity/CEntity.hpp"
#include "../Component/Graphics/CRenderer.hpp"
#include "../Component/Meta/CMetaData.hpp"
#include "../Component/Geometry/CTransform.hpp"
#include "../Component/Camera/CCamera.hpp"
#include "../Component/Relationships/CRelationship.hpp"
#include "../Graphics/API/GraphicsAPI.hpp"
#include "../Graphics/Data/CModelLoader.hpp"

#include <memory>
#include <vector>
namespace CosmicCore {

	CScene::CScene(std::string name) : CSerializable(),
									m_name(std::move(name)) {
	}


	std::string CScene::getName(void) const {
		return m_name;
	}

	CEntity CScene::addEntity(std::string name, std::string description){
		VulkanImpl* api = dynamic_cast<VulkanImpl*>(GraphicsAPI::getAPI().get());

		auto handle = m_ecManager.registry.create();
		CEntity handler(m_ecManager, handle, this);
		m_ecManager().emplace<CTransform>(handle, handler);
		m_ecManager().emplace<CMetaData>(handle, handler, std::move(name), std::move(description));

		auto& rM = GraphicsAPI::getAPI()->getResourceManager();

		auto model = CModelLoader::loadModel("assets/models/cube.glb", rM);
		
		rM.getTextureManager().loadedTextures.push_back(std::make_unique<CTexture>("assets/shrekt.png"));
		auto texture = rM.getTextureManager().loadedTextures.back().get();
		texture->init();
		for(auto& mesh : model->getMeshes())
		{
			mesh->getMaterial()->textureAlbedo = texture;
			mesh->getMaterial()->build();
		}

		m_ecManager().emplace<CRenderer>(handle, handler, model);
		auto& tr = m_ecManager.registry.get<CTransform>(handle);
		tr.initUniformBuffer(dynamic_cast<VulkanImpl*>(GraphicsAPI::getAPI().get())->getAllocator());
		tr.updateUniformBuffer(0);
		tr.updateUniformBuffer(1);

		auto camHandle = m_ecManager.registry.create();
		CEntity handlerCam(m_ecManager, camHandle, this);

		auto& transform = m_ecManager().emplace<CTransform>(camHandle, handlerCam);
		auto& cam = m_ecManager.registry.emplace<CCamera>(camHandle, handlerCam);

		m_ecManager.registry.emplace<CRelationship>(camHandle, handlerCam, std::vector<EntityId>{handle});
		m_ecManager.registry.emplace<CRelationship>(handle, handler, camHandle);

		transform.setCenter({0.0f, 0.9f, 3.0f});
		cam.setAspect((float)api->getSwapChainExtent().width / api->getSwapChainExtent().height);
		cam.initUniformBuffer(api->getAllocator());
		cam.updateUniformBuffer(0, transform);
		cam.updateUniformBuffer(1, transform);
		return handler;
	}

	unsigned int CScene::getNumEntity(void) const {
		return m_ecManager().view<CMetaData>()->size();
	}

	void CScene::removeEntity(unsigned int index, bool destroy)
	{

	}

	void CScene::render(vk::raii::CommandBuffer& cmd, uint32_t frameIndex){
		auto entities = m_ecManager.registry.view<CRenderer, CTransform>();
		VulkanImpl* api = dynamic_cast<VulkanImpl*>(GraphicsAPI::getAPI().get());
		auto cam = m_ecManager.registry.view<CCamera, CTransform>();
		auto& camera = m_ecManager.registry.get<CCamera>(cam.front());
		auto& transform = m_ecManager.registry.get<CTransform>(cam.front());

		camera.updateUniformBuffer(frameIndex, transform);

		cmd.bindDescriptorSets(
			vk::PipelineBindPoint::eGraphics,
			api->getDefaultPipelineLayout(), // layout du pipeline
			0,
			*camera.getDescriptorSet(frameIndex),
			{}
		);

        for (auto& entity : entities) {
            auto model     = m_ecManager.registry.get<CRenderer>(entity).getModel();
            auto& transform = m_ecManager.registry.get<CTransform>(entity);

			transform.updateUniformBuffer(frameIndex);
			//trier meshes par matérial ?

			// bind transform UBO (set = 1)
			cmd.bindDescriptorSets(
				vk::PipelineBindPoint::eGraphics,
				api->getDefaultPipelineLayout(), // layout du pipeline
				1,                                         // set = 1
				*transform.getDescriptorSet(frameIndex),
				{}
			);

            for (auto& mesh : model->getMeshes()) {
                // ne rebind le pipeline que si le material change
                //if (mesh.getMaterial() != boundMaterial) {
                    //boundMaterial = mesh.getMaterial();
                    cmd.bindPipeline(vk::PipelineBindPoint::eGraphics,
                                     *mesh->getMaterial()->getPipeline());
                    cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
						 *mesh->getMaterial()->getPipelineLayout(),
						 2,
						  *mesh->getMaterial()->getDescriptorSet(frameIndex),
						{});
                //}
				
				cmd.bindVertexBuffers(0, vk::Buffer(mesh->getVertexIndexBuffer().buffer), mesh->getVertexOffset());
				cmd.bindIndexBuffer(vk::Buffer(mesh->getVertexIndexBuffer().buffer), mesh->getIndexOffset(), vk::IndexType::eUint32);
				cmd.drawIndexed(mesh->getIndexCount(), 1, 0, 0, 0);
            }
        }
	}

	// void CScene::setMask(unsigned int mask)
	// {
	// 	m_maskLayer = mask;
	// }

	// unsigned int CScene::getMask(void)
	// {
	// 	return m_maskLayer;
	// }

	nlohmann::json CScene::to_json()
	{
		return nlohmann::json();
	}
}