#include "CModelCompiler.h"
	#include "CBinaryFile.h"
	#include "CModelLoadInfo.h"
	#include "CScopeExit.h"
	#include "U_Log.h"
	#include "U_Files.h"
	#include <fstream>
	/*
	class CModelLoadInfo
	{
	public:
	class CBone
	{
	public:
	int ParentIndex = -1;
	std::string Name;
	CTransform BindTransform;
	};
	class CVertex
	{
	public:
	class CBoneLink
	{
	public:
	float Weight = 1.0f;
	int BoneIndex = -1;
	};
	//TODO vertex color
	glm::vec3 Position;
	std::uint8_t BoneCount = 0;
	std::vector<CBoneLink> Bones;
	};
	class CTriangle
	{
	public:
	glm::u64vec3 VertexIndex;
	glm::u64vec3 UvIndex;
	glm::u64vec3 NormalIndex;
	int MaterialIndex = -1;
	};
	std::vector<CBone> Bones;
	std::vector<CVertex> Vertices;
	std::vector<glm::vec2> UvCoords;
	std::vector<glm::vec3> Normals;
	std::vector<CTriangle> Triangles;
	std::vector<std::string> MaterialsList;
	void Reset();
	bool Load(const std::filesystem::path& path);
	int CheckBoneValidity(CBone& bone);
	bool CheckIndices(const glm::u64vec3& vec, size_t limit);
	};
	*/
	bool CModelCompiler::CompileModel(const std::filesystem::path& srcpath)
	{
	CModelLoadInfo model;
	std::ifstream objfile(srcpath);
	if (!objfile.is_open()) { Log::ErrInstance() << "Can't open source file\n"; return false; }
	CScopeExit streamExiter([&objfile]() { objfile.close(); });
	std::filesystem::path outpath = FileUtils::get_executable_path() / "resources" / "models" / (srcpath.stem().string() + ".emdl");
	CBinaryFile outfile(outpath, false); //closed on destructor
	if(!outfile.IsOpen()) { Log::ErrInstance() << "Can't open output file\n"; return false; }
	glm::vec3 Scale{ 1.0f, 1.0f, 1.0f };
	std::vector<CModelLoadInfo::CVertex::CBoneLink> CurrentBoneLinking;
	int CurrentMaterial = -1;
	std::string ReadLine;
	while (!objfile.eof())
	{
	std::getline(objfile, ReadLine, '\n');
	if (ReadLine.substr(0, 5) == "scale")
	{
	std::vector<std::string> splitted;
	StringUtils::split_str(ReadLine, ' ', splitted);
	float scl = atof(splitted[1].c_str());
	Scale = { scl, scl, scl };
	Log::Instance() << "Scaled to " << scl << "\n";
	}
	else if (ReadLine.substr(0, 6) == "scale3")
	{
	std::vector<std::string> splitted;
	StringUtils::split_str(ReadLine, ' ', splitted);
	float scl[3];
	for(int i = 0; i < 3; i++) { scl[i] = atof(splitted[i + 1].c_str()); }
	Scale = { scl[0], scl[1], scl[2] };
	Log::Instance() << "Scaled to { " << StringUtils::ToStr(Scale) << " }\n";
	}
	else if (ReadLine[0] == 'v')
	{
	if (ReadLine[1] == 't')
	{
	float X, Y;
	sscanf(ReadLine.c_str(), "vt %f %f", &X, &Y);
	model.UvCoords.push_back({ X, Y });
	}
	else if (ReadLine[1] == 'n')
	{
	float X, Y, Z;
	sscanf(ReadLine.c_str(), "vn %f %f %f", &X, &Y, &Z);
	model.Normals.push_back({ X, Y, Z });
	}
	else
	{
	float X, Y, Z;
	sscanf(ReadLine.c_str(), "v %f %f %f", &X, &Y, &Z);
	X *= Scale.x;
	Y *= Scale.y;
	Z *= Scale.z;
	CModelLoadInfo::CVertex vertex;
	vertex.BoneCount = CurrentBoneLinking.size();
	vertex.Bones = CurrentBoneLinking;
	vertex.Position = { X, Y, Z };
	model.Vertices.push_back(vertex);
	}
	}
	else if (ReadLine[0] == 'l')
	{
	ReadLine.erase(0, 2);
	bool found = std::find(model.MaterialsList.begin(), model.MaterialsList.end(), ReadLine) != model.MaterialsList.end();
	if (!found)
	{
	model.MaterialsList.push_back(ReadLine);
	Log::Instance() << "Added material " << ReadLine << "\n";
	}
	CurrentMaterial = std::distance(model.MaterialsList.begin(), std::find(model.MaterialsList.begin(), model.MaterialsList.end(), ReadLine));
	}
	else if (ReadLine[0] == 'm')
	{
	ReadLine.erase(0, 2);
	bool found = std::find(model.MaterialsList.begin(), model.MaterialsList.end(), ReadLine) != model.MaterialsList.end();
	if (!found)
	{
	model.MaterialsList.push_back(ReadLine);
	Log::Instance() << "Forced material " << ReadLine << "\n";
	}
	CurrentMaterial = std::distance(model.MaterialsList.begin(), std::find(model.MaterialsList.begin(), model.MaterialsList.end(), ReadLine));
	}
	else if (ReadLine[0] == 'f')
	{
	int vertex[3];
	int texture[3];
	int normal[3];
	sscanf(ReadLine.c_str(), "f %d/%d/%d %d/%d/%d %d/%d/%d", &vertex[0], &texture[0], &normal[0], &vertex[1], &texture[1], &normal[1], &vertex[2], &texture[2], &normal[2]);
	CModelLoadInfo::CTriangle triangle;
	for(int i = 0; i < 3; i++) { triangle.VertexIndex[i] = vertex[i] - 1; }
	for(int i = 0; i < 3; i++) { triangle.UvIndex[i] = texture[i] - 1; }
	for(int i = 0; i < 3; i++) { triangle.NormalIndex[i] = normal[i] - 1; }
	triangle.MaterialIndex = CurrentMaterial;
	model.Triangles.push_back(triangle);
	}
	else if (ReadLine[0] == 'j')
	{
	if (ReadLine[1] == 'c')
	{
	ReadLine.erase(0, 3);
	std::vector<std::string> splitted;
	StringUtils::split_str(ReadLine, ' ', splitted);
	std::string boneName = splitted.front();
	splitted.erase(splitted.begin());
	std::string boneParentName;
	bool found = std::find_if(model.Bones.begin(), model.Bones.end(), [&boneName](auto& bone) -> bool
	{
	return bone.Name == boneName;
	}) != model.Bones.end();
	if (found)
	{
	continue;
	}
	CModelLoadInfo::CBone bone;
	bone.Name = boneName;
	size_t transformIndex = 1;
	if(!StringUtils::isNumber(splitted.front()))
	{
	boneParentName = splitted.front();
	splitted.erase(splitted.begin());
	auto parentIt = std::find_if(model.Bones.begin(), model.Bones.end(), [&boneParentName](auto& bone) -> bool
	{
	return bone.Name == boneParentName;
	});
	if(parentIt == model.Bones.end())
	{
	Log::ErrInstance() << "Can't find parent bone \"" << boneParentName << "\" for \"" << bone.Name << "\"\n";
	return false;
	}
	bone.ParentIndex = std::distance(model.Bones.begin(), parentIt);
	transformIndex = 2;
	}
	//glm::vec3 Position, Scale;
	//glm::quat Rotation;
	glm::mat4 bindMatrix;
	for(size_t y = 0; y < glm::mat4::length(); y++)
	{
	for(size_t x = 0; x < glm::mat4::length(); x++)
	{
	bindMatrix[x][y] = StringUtils::FromStr<float>(splitted.front());
	splitted.erase(splitted.begin());
	}
	}
	//for(size_t i = 0; i < Position.length(); i++) { Position[i] = StringUtils::FromStr<float>(splitted.front()); splitted.erase(splitted.begin()); }
	//for(size_t i = 0; i < Rotation.length(); i++) { Rotation[i] = StringUtils::FromStr<float>(splitted.front()); splitted.erase(splitted.begin()); }
	//for(size_t i = 0; i < Scale.length(); i++) { Scale[i] = StringUtils::FromStr<float>(splitted.front()); splitted.erase(splitted.begin()); }
	//bone.BindTransform.SetFromMatrix()
	//bone.BindTransform.SetPRS(Position, Rotation, Scale);
	bone.BindTransform = bindMatrix;
	model.Bones.push_back(bone);
	auto thisBoneIt = std::find_if(model.Bones.begin(), model.Bones.end(), [&boneName](auto& bone) -> bool
	{
	return bone.Name == boneName;
	});
	CurrentBoneLinking.clear();
	CModelLoadInfo::CVertex::CBoneLink newLink;
	newLink.BoneIndex = std::distance(model.Bones.begin(), thisBoneIt);
	newLink.Weight = 1.0f;
	CurrentBoneLinking.push_back(newLink);
	}
	else
	{
	CurrentBoneLinking.clear();
	ReadLine.erase(0, 2);
	std::vector<std::string> splitted;
	StringUtils::split_str(ReadLine, ' ', splitted);
	size_t boneCount = 0;
	std::string boneName;
	float boneWeight = 1.0f;
	for(size_t i = 0; i < splitted.size(); i++)
	{
	if(i % 2 == 0)
	{
	boneName = splitted[i];
	}
	else
	{
	boneWeight = StringUtils::FromStr<float>(splitted[i]);
	auto boneIt = std::find_if(model.Bones.begin(), model.Bones.end(), [&boneName](auto& bone) -> bool
	{
	return bone.Name == boneName;
	});
	if(boneIt == model.Bones.end())
	{
	Log::ErrInstance() << "Can't find bone \"" << boneName << "\"\n";
	return false;
	}
	CModelLoadInfo::CVertex::CBoneLink newLink;
	newLink.BoneIndex = std::distance(model.Bones.begin(), boneIt);
	newLink.Weight = boneWeight;
	CurrentBoneLinking.push_back(newLink);
	}
	}
	}
	}
	}
	size_t _dbg_MaterialIndex = 0, _dbg_BoneIndex = 0;
	outfile.Write<std::uint16_t>(model.MaterialsList.size());
	Log::Instance() << "Materials count: " << model.MaterialsList.size() << "\n";
	for(size_t i = 0; i < model.MaterialsList.size(); i++)
	{
	outfile.WriteString(model.MaterialsList.at(i));
	Log::Instance() << "Material #" << _dbg_MaterialIndex << " is " << model.MaterialsList.at(i) << "\n"; _dbg_MaterialIndex++;
	}
	outfile.Write<std::uint16_t>(model.Bones.size());
	Log::Instance() << "Bones count: " << model.Bones.size() << "\n";
	for(size_t i = 0; i < model.Bones.size(); i++)
	{
	outfile.Write(model.Bones.at(i).ParentIndex);
	outfile.WriteString(model.Bones.at(i).Name);
	outfile.Write(model.Bones.at(i).BindTransform);
	//outfile.Write(model.Bones.at(i).BindTransform.GetPosition());
	//outfile.Write(model.Bones.at(i).BindTransform.GetRotation());
	//outfile.Write(model.Bones.at(i).BindTransform.GetScale());
	Log::Instance() << "Bone #" << _dbg_BoneIndex << " is " << model.Bones.at(i).Name << " with parent index of " << model.Bones.at(i).ParentIndex << "\n"; _dbg_BoneIndex++;
	}
	outfile.Write<std::uint64_t>(model.UvCoords.size());
	Log::Instance() << "Uv coords count: " << model.UvCoords.size() << "\n";
	for(size_t i = 0; i < model.UvCoords.size(); i++)
	{
	outfile.Write(model.UvCoords.at(i));
	}
	outfile.Write<std::uint64_t>(model.Normals.size());
	Log::Instance() << "Normals count: " << model.Normals.size() << "\n";
	for(size_t i = 0; i < model.Normals.size(); i++)
	{
	outfile.Write(model.Normals.at(i));
	}
	outfile.Write<std::uint64_t>(model.Vertices.size());
	Log::Instance() << "Vertices count: " << model.Vertices.size() << "\n";
	for(size_t i = 0; i < model.Vertices.size(); i++)
	{
	outfile.Write(model.Vertices.at(i).Position);
	outfile.Write(model.Vertices.at(i).BoneCount);
	size_t _dbg_BoneCycles = 0;
	for(std::uint8_t j = 0; j < model.Vertices.at(i).BoneCount; j++)
	{
	outfile.Write(model.Vertices.at(i).Bones.at(j).BoneIndex);
	outfile.Write(model.Vertices.at(i).Bones.at(j).Weight);
	_dbg_BoneCycles++;
	}
	if(_dbg_BoneCycles != model.Vertices.at(i).BoneCount)
	{
	Log::Errln("Warning! There's mismatch in actual written bones count and BoneCount var!");
	}
	}
	outfile.Write<std::uint64_t>(model.MaterialsList.size());
	for(size_t i = 0; i < model.MaterialsList.size(); i++)
	{
	outfile.Write<int>(i);
	std::uint64_t count = 0;
	for(auto& tri : model.Triangles)
	{
	if(tri.MaterialIndex == i)
	{
	count++;
	}
	}
	Log::Instance() << "Writing " << count << " polygons for material #" << i << "\n";
	outfile.Write<std::uint64_t>(count);
	for(auto& tri : model.Triangles)
	{
	if(tri.MaterialIndex == i)
	{
	outfile.Write(tri.VertexIndex);
	outfile.Write(tri.UvIndex);
	outfile.Write(tri.NormalIndex);
	}
	}
	}
	Log::Instance() << "Model info loaded!\n";
	return true;
	}