#include "EngineInit.h"

#include "Core/Logger.h"
#include "Core/GarbageCollection.h"
#include "Core/ThreadSyncManager.h"
#include "Core/ThreadPool.h"
#include "Core/Factory.hpp"
#include "Core/AssetResolver.h"

#include "Window/Window.h"
#include "Render/VulkanImpl/VulkanRenderer.h"

#include "Sound/SoundSystem.h"

#include "Game/ImGUImpl.h"
#include "Game/RenderThread.h"
#include "Game/Input.h"
#include "Game/Component/Component.h"
#include "Game/ComponentModule.h"
#include "Game/GameManager.h"
#include "Game/ScriptableObject.h"

#if SH_EDITOR
#include "Editor/EditorResource.h"
#include "Editor/EditorWorld.h"
#include "Editor/AssetDatabase.h"
#include "Editor/UI/CustomInspector.h"
#else
#include "Core/AssetBundle.h"

#include "Render/VulkanImpl/VulkanShaderPassBuilder.h"
#include "Render/VulkanImpl/VulkanContext.h"

#include "Game/World.h"
#include "Game/AssetLoaderFactory.h"
#include "Game/Asset/TextureLoader.h"
#include "Game/Asset/ModelLoader.h"
#include "Game/Asset/MeshLoader.h"
#include "Game/Asset/MaterialLoader.h"
#include "Game/Asset/ShaderLoader.h"
#include "Game/Asset/WorldLoader.h"
#include "Game/Asset/PrefabLoader.h"
#include "Game/Asset/TextLoader.h"
#include "Game/Asset/BinaryLoader.h"
#include "Game/Asset/FontLoader.h"
#include "Game/Asset/SoundLoader.h"
#include "Game/Asset/ScriptableObjectLoader.h"
#include "Game/Asset/ComputeShaderLoader.h"

#include "Game/Asset/TextureAsset.h"
#include "Game/Asset/MaterialAsset.h"
#include "Game/Asset/ShaderAsset.h"
#include "Game/Asset/ModelAsset.h"
#include "Game/Asset/MeshAsset.h"
#include "Game/Asset/WorldAsset.h"
#include "Game/Asset/PrefabAsset.h"
#include "Game/Asset/TextAsset.h"
#include "Game/Asset/BinaryAsset.h"
#include "Game/Asset/FontAsset.h"
#include "Game/Asset/SoundAsset.h"
#include "Game/Asset/ScriptableObjectAsset.h"
#include "Game/Asset/ComputeShaderAsset.h"
#endif

namespace sh
{
	EngineInit::EngineInit() :
		moduleLoader()
	{
	}
	EngineInit::~EngineInit()
	{
		Clean();
	}
	void EngineInit::Clean()
	{
		SH_INFO("Engine shutdown");
		gameManager->Destroy();
#if SH_EDITOR
		project.reset();
		editor::AssetDatabase::Destroy();
		editor::EditorResource::Destroy();
		editor::CustomInspectorManager::Destroy();
#endif
		renderer->WaitForCurrentFrame();

		while(gc->GetRootSetCount() != gc->GetObjectCount())
		{
			gc->Collect();
			gc->DestroyPendingKillObjs();
		}
		gui.reset();
		renderer.reset();
		sound::SoundSystem::Destroy();

		window.reset();
	}

	inline void EngineInit::InitResource()
	{
		SH_INFO("Resource initialization");
#if SH_EDITOR
		editor::EditorResource::GetInstance()->LoadAllAssets(*project);
#endif
	}

	void EngineInit::ProcessInput()
	{
		game::Input::Update();

		sh::window::Event e;
		while (window->PollEvent(e))
		{
			game::Input::UpdateEvent(e);
			gui->ProcessEvent(e);
			switch (e.type)
			{
			case sh::window::Event::EventType::Close:
				bStop = true;
				break;
			case sh::window::Event::EventType::Resize:
				if (window->GetWidth() == 0)
				{
					renderer->Pause(true);
				}
				else
				{
					renderer->Pause(false);
					renderThread->AddBeginTaskFromOtherThread(
						[renderer = renderer.get(), width = window->GetWidth(), height = window->GetHeight()]
						{
							renderer->GetContext()->SetViewport({ 0, 0.f }, { width, height }); 
						}
					);
					gui->Resize();
				}
				break;
			case sh::window::Event::EventType::WindowFocus:
				SH_INFO("FocusIn");
				break;
			case sh::window::Event::EventType::WindowFocusOut:
				SH_INFO("FocusOut");
				sh::game::Input::ResetKeyState();
				break;
			}
		}
	}

	void EngineInit::Start()
	{
		SH_INFO("Engine start");
		game::ComponentModule* componentModule = game::ComponentModule::GetInstance();
		componentModule->RegisterWaitingComponents();

		SH_INFO_FORMAT("Init {} type", game::ScriptableObject::GetStaticType().name.ToString()); // 타입이 존재하는 곳을 메인 static 영역에 지정하기 위해..

		SH_INFO_FORMAT("System thread count: {}", std::thread::hardware_concurrency());

		SH_INFO("GarbageCollection initialization");
		gc = core::GarbageCollection::GetInstance(); // GC 초기화

		SH_INFO("Window initialization");
		window = std::make_unique<window::Window>();
		window->Create(u8"ShellEngine", 1024, 768, sh::window::Window::Style::Resize);
		window->SetFps(limitFps);

		SH_INFO("Renderer initialization");
		renderer = std::make_unique<sh::render::vk::VulkanRenderer>();
		renderer->CreateContext(*window);
		renderer->Init(*window);
		renderer->GetContext()->SetViewport({ 150.f, 0.f }, { window->GetWidth() - 150.f, window->GetHeight() - 180});

		SH_INFO("SoundSystem initialization");
		sound::SoundSystem::GetInstance()->Init();

		SH_INFO("UIContext initialization");
		gui = std::make_unique<game::ImGUImpl>(*window, static_cast<render::vk::VulkanRenderer&>(*renderer));
		gui->Init();

		SH_INFO("GameManager initialization");
		gameManager = game::GameManager::GetInstance();
		gameManager->Init(*renderer, *gui);

		auto& worldFactory = *core::Factory<game::World, game::World*>::GetInstance();
		worldFactory.Register(game::World::GetStaticType().name.ToString(),
			[renderer = renderer.get(), componentModule, gui = gui.get()]() -> game::World*
			{
				return core::SObject::Create<game::World>(*renderer, *gui);
			}
		);

		SH_INFO("Thread creation");
		core::ThreadPool::GetInstance()->Init(std::max(2u, std::thread::hardware_concurrency() / 2));
		core::ThreadSyncManager::Init();
#if SH_EDITOR
		game::Component::SetIsEditor(true);

		// 에셋이 다른 에셋을 필요로 하고 있지만 로드가 안 된 상태에서 호출될 것이다.
		// 두 에셋이 순환 참조를 하고 있을 때 무한 루프에 빠질 걱정은 할 필요 없다.
		// 한 에셋을 로드 할 때 UUID를 먼저 지정한 후에 resolver를 호출 하기 때문
		core::AssetResolverRegistry::SetResolver(
			[this](const core::UUID& uuid) -> core::SObject*
			{
				SH_INFO_FORMAT("Using resolver: {}", uuid.ToString());
				static auto& assetDatabase = *editor::AssetDatabase::GetInstance();
				auto assetInfoPtr = assetDatabase.GetAssetPath(uuid);
				if (assetInfoPtr == nullptr)
					return nullptr;

				if (!assetInfoPtr->originalPath.empty())
					return assetDatabase.ImportAsset(assetInfoPtr->originalPath);
				return assetDatabase.ImportAsset(assetInfoPtr->cachePath);
			}
		);

		project = std::make_unique<editor::Project>(*renderer, *gui);

		worldFactory.Register(editor::EditorWorld::GetStaticType().name.ToString(),
			[project = project.get()]() -> game::World*
			{
				return core::SObject::Create<editor::EditorWorld>(*project);
			}
		);
		auto defaultWorld = core::SObject::Create<editor::EditorWorld>(*project); // 기본 월드
		gameManager->LoadWorld(defaultWorld->GetUUID());
#else
		static render::vk::VulkanShaderPassBuilder vkShaderPassBuilder{ static_cast<render::vk::VulkanContext&>(*renderer->GetContext()) };

		auto assetLoaderFactory = game::AssetLoaderFactory::GetInstance();
		assetLoaderFactory->RegisterLoader(game::TextureAsset::ASSET_NAME, std::make_unique<game::TextureLoader>(*renderer->GetContext()));
		assetLoaderFactory->RegisterLoader(game::ModelAsset::ASSET_NAME, std::make_unique<game::ModelLoader>(*renderer->GetContext()));
		assetLoaderFactory->RegisterLoader(game::MeshAsset::ASSET_NAME, std::make_unique<game::MeshLoader>(*renderer->GetContext()));
		assetLoaderFactory->RegisterLoader(game::MaterialAsset::ASSET_NAME, std::make_unique<game::MaterialLoader>(*renderer->GetContext()));
		assetLoaderFactory->RegisterLoader(game::ShaderAsset::ASSET_NAME, std::make_unique<game::ShaderLoader>(&vkShaderPassBuilder));
		assetLoaderFactory->RegisterLoader(game::WorldAsset::ASSET_NAME, std::make_unique<game::WorldLoader>());
		assetLoaderFactory->RegisterLoader(game::PrefabAsset::ASSET_NAME, std::make_unique<game::PrefabLoader>());
		assetLoaderFactory->RegisterLoader(game::TextAsset::ASSET_NAME, std::make_unique<game::TextLoader>());
		assetLoaderFactory->RegisterLoader(game::BinaryAsset::ASSET_NAME, std::make_unique<game::BinaryLoader>());
		assetLoaderFactory->RegisterLoader(game::FontAsset::ASSET_NAME, std::make_unique<game::FontLoader>());
		assetLoaderFactory->RegisterLoader(game::SoundAsset::ASSET_NAME, std::make_unique<game::SoundLoader>());
		assetLoaderFactory->RegisterLoader(game::ScriptableObjectAsset::ASSET_NAME, std::make_unique<game::ScriptableObjectLoader>());
		assetLoaderFactory->RegisterLoader(game::ComputeShaderAsset::ASSET_NAME, std::make_unique<game::ComputeShaderLoader>(*renderer->GetContext()));

		core::AssetResolverRegistry::SetResolver(
			[this](const core::UUID& uuid) -> core::SObject*
			{
				auto asset = assetBundle->LoadAsset(uuid);
				if (asset == nullptr)
					return nullptr;
				static game::AssetLoaderFactory& factory = *game::AssetLoaderFactory::GetInstance();
				auto assetLoader = factory.GetLoader(asset->GetType());
				if (assetLoader == nullptr)
					return nullptr;
				core::SObject* assetPtr = assetLoader->Load(*asset);
				return assetPtr;
			}
		);

		assetBundle = std::make_unique<core::AssetBundle>();
		if (!assetBundle->LoadBundle("assets.bundle"))
			return;
		if (!gameManager->LoadGame("gameManager.bin", *assetBundle))
			return;
 #endif
		SH_INFO("Render thread creation");
		renderThread = game::RenderThread::GetInstance();
		renderThread->Init(*renderer);
		core::ThreadSyncManager::AddThread(*renderThread);

		InitResource();

		renderThread->Run();

		SH_INFO("Start loop");
		Loop();
		SH_INFO("End loop");

		renderThread->Stop();
		renderThread->GetThread().join();
	}

	inline void EngineInit::Loop()
	{
		while (!bStop)
		{
			window->ProcessFrame();

			std::string deltaTime = std::to_string(window->GetDeltaTime());
			deltaTime.erase(deltaTime.begin() + 5, deltaTime.end());
			window->SetTitle("ShellEngine [DeltaTime:" + deltaTime + "ms]");

			ProcessInput();
			if (bStop)
				return;

			gameManager->UpdateWorlds(window->GetDeltaTime()); // 스레드간 Sync도 여기서 이뤄짐
			gc->Update();

			core::ThreadSyncManager::AwakeThread();
		}
	}
}