#include "Game/PCH.h"
#include "AssetDatabase.h"

#include "Game/World.h"
#include "Game/TextureLoader.h"
#include "Game/ModelLoader.h"
#include "Game/MaterialLoader.h"

#include "Core/FileLoader.h"

#include <random>
#include <istream>
#include <ostream>
#include <cassert>
#include <algorithm>

namespace sh::editor
{
	core::Observer<false, core::SObject*>::Listener AssetDatabase::onDestroyListener{ [&](core::SObject* destoryedObj)
		{
			auto it = std::find(dirtyObjs.begin(), dirtyObjs.end(), destoryedObj);
			if (it != dirtyObjs.end())
				dirtyObjs.erase(it);
		}
	};

	void AssetDatabase::CreateMeta(core::SObject* ptr, const std::filesystem::path& metaDir)
	{
		core::Json metaJson = ptr->Serialize();
		std::ofstream os{ metaDir.string() };
		if (os.is_open())
		{
			os << std::setw(4) << metaJson;
			os.close();
		}
		else
		{
			SH_ERROR_FORMAT("Can't create meta: {}", metaDir.string());
		}
	}
	void AssetDatabase::CreateOrLoadMeta(core::SObject* ptr, const std::filesystem::path& metaDir)
	{
		if (std::filesystem::exists(metaDir))
		{
			core::FileLoader loader;
			auto file = loader.LoadText(metaDir.string());
			if (!file)
			{
				SH_ERROR_FORMAT("Can't load file: {}", metaDir.string());
				return;
			}
			if (file.value().empty())
			{
				CreateMeta(ptr, metaDir);
				return;
			}
			core::Json metaJson{ core::Json::parse(file.value()) };
			ptr->Deserialize(metaJson);
			assert(ptr->GetUUID().ToString() == metaJson["uuid"].get<std::string>());
		}
		else
		{
			CreateMeta(ptr, metaDir);
		}
	}

	auto AssetDatabase::LoadMesh(game::World& world, const std::filesystem::path& dir, const std::filesystem::path& metaDir) -> render::Mesh*
	{
		static game::ModelLoader loader{ world.renderer };
		auto ptr = loader.Load(dir.string());
		if (ptr == nullptr)
			return nullptr;

		world.meshes.AddResource(dir.string(), ptr);
		ptr->SetName(dir.stem().string());

		CreateOrLoadMeta(ptr, metaDir);
		uuids.insert_or_assign(dir, ptr->GetUUID());
		paths.insert_or_assign(ptr->GetUUID().ToString(), dir);

		return ptr;
	}
	auto AssetDatabase::LoadTexture(game::World& world, const std::filesystem::path& dir, const std::filesystem::path& metaDir) -> render::Texture*
	{
		static game::TextureLoader loader{ world.renderer };
		auto ptr = loader.Load(dir.string());
		if (ptr == nullptr)
			return nullptr;

		world.textures.AddResource(dir.string(), ptr);
		ptr->SetName(dir.stem().u8string());

		CreateOrLoadMeta(ptr, metaDir);
		uuids.insert_or_assign(dir, ptr->GetUUID());
		paths.insert_or_assign(ptr->GetUUID().ToString(), dir);

		return ptr;
	}
	auto AssetDatabase::LoadMaterial(game::World& world, const std::filesystem::path& dir) -> render::Material*
	{
		static game::MaterialLoader loader{ world.renderer };
		
		auto ptr = loader.Load(dir.string());
		if (ptr == nullptr)
			return nullptr;

		world.materials.AddResource(dir.string(), ptr);
		ptr->SetName(dir.stem().string());

		uuids.insert_or_assign(dir, ptr->GetUUID());
		paths.insert_or_assign(ptr->GetUUID().ToString(), dir);
		return ptr;
	}
	void AssetDatabase::SaveMaterial(render::Material* mat, const std::filesystem::path& dir)
	{
		if (!core::IsValid(mat))
			return;

		core::Json matJson{ mat->Serialize() };

		std::ofstream os{ dir };
		os << std::setw(4) << matJson;
		os.close();
	}

	SH_EDITOR_API auto AssetDatabase::ImportAsset(game::World& world, const std::filesystem::path& dir) -> core::SObject*
	{
		if (!std::filesystem::exists(dir))
			return nullptr;
		if (std::filesystem::is_directory(dir))
			return nullptr;
		
		std::string filename = dir.filename().string() + ".meta";
		std::string extension = dir.extension().string();
		auto parentDir = dir.parent_path();

		auto metaDir = parentDir / filename;
		bool hasMetaFile = std::filesystem::exists(metaDir);

		if (extension == ".jpg" || extension == ".png")
			return LoadTexture(world, dir, metaDir);
		if (extension == ".obj")
			return LoadMesh(world, dir, metaDir);
		if (extension == ".mat")
			return LoadMaterial(world, dir);
		return nullptr;
	}

	SH_EDITOR_API void AssetDatabase::SaveAllAssets()
	{
		for (auto obj : dirtyObjs)
		{
			auto it = paths.find(obj->GetUUID().ToString());
			if (it == paths.end())
				continue;
			if (obj->GetType() == render::Material::GetStaticType())
			{
				SaveMaterial(static_cast<render::Material*>(obj), it->second);
			}
		}
		dirtyObjs.clear();
	}

	void AssetDatabase::LoadAllAssetsHelper(const std::filesystem::path& dir, bool recursive)
	{
		for (auto& entry : std::filesystem::directory_iterator(dir))
		{
			if (entry.is_directory())
			{
				if (recursive)
					LoadAllAssetsHelper(entry.path(), recursive);
			}
			else if (entry.is_regular_file())
			{
				if (entry.path().extension() == ".meta")
					continue;

				int priority = 0;
				if (entry.path().extension() == ".mat")
					priority = -1;
				loadingAssetsQueue.push(AssetLoadData{ priority, entry.path() });
			}
		}
	}
	SH_EDITOR_API void AssetDatabase::LoadAllAssets(game::World& world, const std::filesystem::path& dir, bool recursive)
	{
		LoadAllAssetsHelper(dir, recursive);
		while (!loadingAssetsQueue.empty())
		{
			AssetLoadData data = std::move(const_cast<AssetLoadData&>(loadingAssetsQueue.top()));
			loadingAssetsQueue.pop();
			ImportAsset(world, data.path);
		}
	}

	SH_EDITOR_API bool AssetDatabase::CreateAsset(game::World& world, const std::filesystem::path& dir, const core::ISerializable& serializable)
	{
		if (std::filesystem::exists(dir))
			return false;

		auto json = serializable.Serialize();
		if (json.contains("uuid"))
			uuids.insert_or_assign(dir, core::UUID(json["uuid"].get<std::string>()));

		std::ofstream os(dir);
		os << std::setw(4) << json;
		os.close();

		return true;
	}

	SH_EDITOR_API auto AssetDatabase::GetAssetUUID(const std::filesystem::path& dir) -> std::optional<core::UUID>
	{
		auto it = uuids.find(dir);
		if (it == uuids.end())
			return std::nullopt;
		return it->second;
	}

	SH_EDITOR_API void AssetDatabase::SetDirty(core::SObject* obj)
	{
		obj->onDestroy.Register(onDestroyListener);
		if(core::IsValid(obj))
			dirtyObjs.push_back(obj);
	}
}//namespace