#include "CModelLoadInfo.h"
	#include "CBinaryFile.h"
	#include "CScopeExit.h"
	#include "U_String.h"
	#include "U_Numbers.h"
	#include "U_Log.h"
	#include "U_Files.h"
	CModelLoadInfo::CBone& CModelLoadInfo::CBone::GetParent(std::vector<CBone>& bones)
	{
	auto it = std::find_if(bones.begin(), bones.end(), [this](const CBone& bone) -> bool { return bone.Name == ParentName; });
	return (*it);
	}
	//BONEMATRIX calculating bind pose here
	void CModelLoadInfo::CBone::CalculateBind(std::vector<CBone>& bones)
	{
	GlobalBind = glm::mat4x4();
	auto LocalBind = BindTransform;
	if(ParentIndex > -1)
	{
	GlobalBind = GetParent(bones).GlobalBind * LocalBind;
	}
	else
	{
	GlobalBind = LocalBind;
	}
	/*Log::Instance() << "Bone " << Name << " local bind is:\n";
	for(size_t y = 0; y < glm::mat4::length(); y++)
	{
	for(size_t x = 0; x < glm::mat4::length(); x++)
	{
	Log::Instance() << LocalBind[x][y] << " ";
	}
	}
	Log::Instance() << Log::Endl << Log::Endl;
	Log::Instance() << "Bone " << Name << " global bind is:\n";
	for(size_t y = 0; y < glm::mat4::length(); y++)
	{
	for(size_t x = 0; x < glm::mat4::length(); x++)
	{
	Log::Instance() << GlobalBind[x][y] << " ";
	}
	}
	Log::Instance() << Log::Endl << Log::Endl;*/
	}
	void CModelLoadInfo::Reset()
	{
	Triangles.clear();
	Normals.clear();
	UvCoords.clear();
	Vertices.clear();
	Bones.clear();
	MaterialsList.clear();
	}
	bool CModelLoadInfo::CheckIndices(const glm::u64vec3& vec, size_t limit)
	{
	return (vec.x < limit || vec.y < limit || vec.z < limit);
	}
	int CModelLoadInfo::CheckBoneValidity(CBone& bone)
	{
	if(StringUtils::IsEmpty(bone.Name)) { return 1; }
	if(bone.ParentIndex < -1 || bone.ParentIndex >= static_cast<int>(Bones.size())) { return 2; }
	if (&bone - Bones.data() == bone.ParentIndex) { return 3; }
	int visitedCount = 0;
	int parentIndex = bone.ParentIndex;
	while (parentIndex != -1)
	{
	if (visitedCount++ > Bones.size())
	{
	return 4;
	}
	if (parentIndex == (&bone - Bones.data()))
	{
	return 5;
	}
	parentIndex = Bones[parentIndex].ParentIndex;
	}
	if (bone.ParentIndex >= 0 && bone.ParentIndex >= static_cast<int>(&bone - Bones.data()))
	{
	return 6;
	}
	return 0;
	}
	bool CModelLoadInfo::Load(const std::filesystem::path& path)
	{
	CScopeExit guard([this]() { Reset(); });
	auto Error = [](const std::string& err) -> bool { Log::Errln(StringUtils::StrToWstr(err)); return false; };
	auto found_path = FileUtils::find_first_by_name(FileUtils::get_executable_path() / "resources" / "models", path.string());
	if(!found_path.has_value()) { return Error("Couldn't find file " + path.string()); }
	CBinaryFile bin;
	bin.OpenRead(found_path.value()); //file closes itself on ~CBinaryFile
	if(!bin.IsOpen()) { return Error("Couldn't open file " + found_path.value().string()); }
	std::uint16_t MaterialsCount, BonesCount;
	std::uint64_t VerticesCount, UvCoordsCount, NormalsCount, MaterialLinksCount;
	bin.Read(MaterialsCount);
	MaterialsList.reserve(MaterialsCount);
	//Log::Instance() << "Materials count: " << MaterialsCount << "\n"; LOGLOG
	for(std::uint16_t i = 0; i < MaterialsCount; i++)
	{
	std::string matname = bin.ReadString();
	//Log::Instance() << "Got material name: \"" << matname << "\"\n"; LOGLOG
	if(!StringUtils::IsEmpty(matname))
	{
	MaterialsList.push_back(matname);
	}
	}
	bin.Read(BonesCount);
	Bones.reserve(BonesCount);
	//Log::Instance() << "Bones count: " << BonesCount << "\n"; LOGLOG
	for(std::uint16_t i = 0; i < BonesCount; i++)
	{
	CBone Bone;
	bin.Read(Bone.ParentIndex);
	bin.ReadString(Bone.Name);
	//Log::Instance() << "Got bone named \"" << Bone.Name << "\" with parent index of " << Bone.ParentIndex << "\n"; LOGLOG
	//CTransform::CMeasurePack transform_pack;
	//bin.Read(transform_pack.Position);
	//bin.Read(transform_pack.Rotation);
	//bin.Read(transform_pack.Scale);
	bin.Read(Bone.BindTransform);
	//Bone.BindTransform.SetPRS(transform_pack);
	Bones.push_back(Bone);
	}
	for(auto& bone : Bones)
	{
	int status = CheckBoneValidity(bone);
	if(status != 0)
	{
	return Error("Invalid bone with the status of " + std::to_string(status) + " was detected at \"" + bone.Name + "\"");
	}
	else
	{
	if(bone.ParentIndex > -1)
	{
	bone.ParentName = Bones.at(bone.ParentIndex).Name;
	}
	bone.CalculateBind(Bones);
	}
	}
	bin.Read(UvCoordsCount);
	UvCoords.reserve(UvCoordsCount);
	//Log::Instance() << "Uv coords count: " << UvCoordsCount << "\n"; LOGLOG
	for(std::uint64_t i = 0; i < UvCoordsCount; i++)
	{
	UvCoords.push_back(bin.Read<glm::vec2>());
	}
	bin.Read(NormalsCount);
	Normals.reserve(NormalsCount);
	//Log::Instance() << "Normals count: " << NormalsCount << "\n"; LOGLOG
	for(std::uint64_t i = 0; i < NormalsCount; i++)
	{
	Normals.push_back(bin.Read<glm::vec3>());
	}
	bin.Read(VerticesCount);
	Vertices.reserve(VerticesCount);
	//Log::Instance() << "Vertices count: " << VerticesCount << "\n"; LOGLOG
	for(std::uint64_t i = 0; i < VerticesCount; i++)
	{
	CVertex vertex;
	bin.Read(vertex.Position);
	bin.Read(vertex.BoneCount);
	float TotalWeight = vertex.BoneCount == 0 ? 1.0f : 0.0f;
	for(std::uint8_t j = 0; j < vertex.BoneCount; j++)
	{
	CVertex::CBoneLink link;
	bin.Read(link.BoneIndex);
	bin.Read(link.Weight);
	if(link.BoneIndex < 0) { return Error("Vertex " + std::to_string(i) + " has invalid bone link"); }
	TotalWeight += link.Weight;
	vertex.Bones.push_back(link);
	}
	if(!almost_equal(TotalWeight, 1.0f, 0.1f))
	{
	return Error("Bad total weight of " + std::to_string(TotalWeight) + " at vertex " + std::to_string(i));
	}
	Vertices.push_back(vertex);
	}
	bin.Read(MaterialLinksCount);
	//Log::Instance() << "Material links count: " << MaterialLinksCount << "\n"; LOGLOG
	for(std::uint64_t i = 0; i < MaterialLinksCount; i++)
	{
	int materialIndex = -1;
	bin.Read(materialIndex);
	if(materialIndex < -1 || materialIndex >= static_cast<int>(MaterialsList.size()))
	{
	return Error("Invalid material index (" + std::to_string(materialIndex) + ") with available range of [-1; " + std::to_string(static_cast<int>(MaterialsList.size())) + "]");
	}
	std::uint64_t TrianglesCount;
	bin.Read(TrianglesCount);
	for(std::uint64_t i = 0; i < TrianglesCount; i++)
	{
	CTriangle triangle;
	bin.Read(triangle.VertexIndex);
	bin.Read(triangle.UvIndex);
	bin.Read(triangle.NormalIndex);
	if(!CheckIndices(triangle.VertexIndex, Vertices.size()))
	{
	return Error("Invalid vertex index (" +
	std::to_string(triangle.VertexIndex.x) + ", " + std::to_string(triangle.VertexIndex.y) + ", " + std::to_string(triangle.VertexIndex.z) +
	") with available range of [0; " + std::to_string(static_cast<int>(Vertices.size())) + "]");
	//return Error("Invalid vertex index");
	}
	if(!CheckIndices(triangle.UvIndex, UvCoords.size()))
	{
	return Error("Invalid UV coord index (" +
	std::to_string(triangle.UvIndex.x) + ", " + std::to_string(triangle.UvIndex.y) + ", " + std::to_string(triangle.UvIndex.z) +
	") with available range of [0; " + std::to_string(static_cast<int>(UvCoords.size())) + "]");
	//return Error("Invalid UV coord index");
	}
	if(!CheckIndices(triangle.NormalIndex, Normals.size()))
	{
	return Error("Invalid normal vector index (" +
	std::to_string(triangle.NormalIndex.x) + ", " + std::to_string(triangle.NormalIndex.y) + ", " + std::to_string(triangle.NormalIndex.z) +
	") with available range of [0; " + std::to_string(static_cast<int>(Normals.size())) + "]");
	//return Error("Invalid normal vector index");
	}
	triangle.MaterialIndex = materialIndex;
	Triangles.push_back(triangle);
	}
	}
	guard.Dismiss();
	return true;
	}