#include "ehs/io/mdl/Mdl.h"

namespace ehs
{
	Array<MdlCodec> Mdl::codecs;

	bool Mdl::HasCodec(const UInt_64 hashExt)
	{
		for (UInt_64 i = 0; i < codecs.Size(); ++i)
			if (codecs[i].GetHashExt() == hashExt)
				return true;

		return false;
	}

	bool Mdl::HasCodec(const Str_8& ext)
	{
		return HasCodec(ext.Hash_64());
	}

	bool Mdl::AddCodec(MdlCodec codec)
	{
		if (HasCodec(codec.GetHashExt()))
			return false;

		codecs.Push(std::move(codec));

		return true;
	}

	const MdlCodec* Mdl::GetCodec(const UInt_64 hashExt)
	{
		for (UInt_64 i = 0; i < codecs.Size(); ++i)
			if (codecs[i].GetHashExt() == hashExt)
				return &codecs[i];

		return nullptr;
	}

	const MdlCodec* Mdl::GetCodec(const Str_8& ext)
	{
		return GetCodec(ext.Hash_64());
	}

	Mdl::Mdl()
		: hashId(0)
	{
		AddType("Mdl");
	}

	Mdl::Mdl(const Str_8& filePath)
	{
		AddType("Mdl");

		File file(filePath, Mode::READ, Disposition::OPEN);
		Str_8 ext = file.GetExtension();
		hashId = file.GetName().Hash_64();
		id = file.GetName();

		const MdlCodec* codec = GetCodec(ext);
		if (!codec)
		{
			EHS_LOG_INT(LogType::ERR, 0, "Codec not found for file extension, \"" + ext + "\".");
			return;
		}

		Serializer<UInt_64> data = file.ReadSerializer_64(codec->GetEndianness(), file.Size());

		file.Release();

		codec->Decode(data, this);
	}

	Mdl::Mdl(Str_8 id, Array<Mesh> meshes, Bone skeleton, Array<Animation> animations)
		: hashId(id.Hash_64()), id((Str_8&&)id), meshes((Array<Mesh>&&)meshes), skeleton((Bone&&)skeleton),
		animations((Array<Animation>&&)animations)
	{
		AddType("Mdl");
	}

	Mdl::Mdl(Str_8 id, Array<Mesh> meshes, Bone skeleton)
		: hashId(id.Hash_64()), id((Str_8&&)id), meshes((Array<Mesh>&&)meshes), skeleton((Bone&&)skeleton)
	{
		AddType("Mdl");
	}

	Mdl::Mdl(Str_8 id, Array<Mesh> meshes)
		: hashId(id.Hash_64()), id((Str_8&&)id), meshes((Array<Mesh>&&)meshes)
	{
		AddType("Mdl");
	}

	Mdl::Mdl(Mdl&& model) noexcept
		: BaseObj((BaseObj&&)model), hashId(model.hashId), id((Str_8&&)model.id), meshes((Array<Mesh>&&)model.meshes),
		skeleton((Bone&&)model.skeleton), animations((Array<Animation>&&)model.animations)
	{
	}

	Mdl& Mdl::operator=(Mdl&& model) noexcept
	{
		if (this == &model)
			return *this;

		BaseObj::operator=((BaseObj&&)model);

		hashId = model.hashId;
		id = (Str_8&&)model.id;
		meshes = (Array<Mesh>&&)model.meshes;
		skeleton = (Bone&&)model.skeleton;
		animations = (Array<Animation>&&)model.animations;

		model.hashId = 0;

		return *this;
	}

	void Mdl::Release()
	{
		meshes.Clear();
		skeleton = {};
		animations.Clear();
	}

	UInt_64 Mdl::GetHashId() const
	{
		return hashId;
	}

	void Mdl::SetId(Str_8 newId)
	{
		hashId = newId.Hash_64();
		id = (Str_8&&)newId;
	}

	Str_8 Mdl::GetId() const
	{
		return id;
	}

	const Array<Mesh>& Mdl::GetMeshes() const
	{
		return meshes;
	}

	Array<Mesh>& Mdl::GetMeshes()
	{
		return meshes;
	}

	Mesh* Mdl::GetMesh(const UInt_64 inHashId)
	{
		for (UInt_64 i = 0; i < meshes.Size(); ++i)
			if (meshes[i].GetHashId() == inHashId)
				return &meshes[i];

		return nullptr;
	}

	Mesh* Mdl::GetMesh(const Str_8& inId)
	{
		return GetMesh(inId.Hash_64());
	}

	const Bone& Mdl::GetSkeleton() const
	{
		return skeleton;
	}

	Bone& Mdl::GetSkeleton()
	{
		return skeleton;
	}

	Animation* Mdl::GetAnimation(const UInt_64 inHashId)
	{
		for (UInt_64 i = 0; i < animations.Size(); ++i)
			if (animations[i].GetHashId() == inHashId)
				return &animations[i];

		return nullptr;
	}

	const Array<Animation>& Mdl::GetAnimations() const
	{
		return animations;
	}

	Array<Animation>& Mdl::GetAnimations()
	{
		return animations;
	}

	void Mdl::Calculate()
	{
		for (UInt_64 i = 0; i < meshes.Size(); ++i)
			meshes[i].Calculate();
	}

	bool Mdl::Export(const Str_8& filePath) const
	{
		Str_8 ext = File::ParseExt_8(filePath);

		const MdlCodec* codec = GetCodec(ext);
		if (!codec)
		{
			EHS_LOG_INT(LogType::ERR, 0, "Codec not found for file extension, \"" + ext + "\".");
			return false;
		}

		Serializer<UInt_64> result;
		if (!codec->Encode(result, this))
			return false;

		File file(filePath, Mode::WRITE, Disposition::CREATE_PERSISTENT);
		file.WriteSerializer_64(result);

		return true;
	}

	bool EncodeEHM(const MdlCodec* const codec, Serializer<UInt_64>& data, const Mdl* const mdl)
	{
		const Array<Mesh>& meshes = mdl->GetMeshes();

		data.WriteVersion({1, 0, 0});
		data.Write<UInt_64>(meshes.Size());

		for (UInt_64 i = 0; i < meshes.Size(); ++i)
		{
			data.WriteStr(meshes[i].GetId());

			Array<Vertex_f> vertices = meshes[i].GetVertices();

			data.Write<UInt_64>(vertices.Size());

			for (UInt_64 v = 0; v < vertices.Size(); ++v)
			{
				data.WriteVec3(vertices[v].pos);
				data.WriteVec3(vertices[v].normal);
				data.WriteVec2(vertices[v].uv);
			}
		}

		return true;
	}

	bool DecodeEHM(const MdlCodec* const codec, Serializer<UInt_64>& data, Mdl* const mdl)
	{
		Version ver = data.ReadVersion();
		if (ver != Version(1, 0, 0))
		{
			EHS_LOG_INT(LogType::ERR, 0, "Cannot decode EHM file version " + Str_8::FromNum(ver.major) + "." +
									Str_8::FromNum(ver.minor) + "." + Str_8::FromNum(ver.patch) +
									", must be version 0.0.0.");
			return false;
		}

		Array<Mesh>& meshes = mdl->GetMeshes();
		meshes.Resize(data.Read<UInt_64>());

		for (UInt_64 i = 0; i < meshes.Size(); ++i)
		{
			meshes[i].SetId(data.ReadStr<Char_8, UInt_64>());

			Array<Vertex_f>& vertices = meshes[i].GetVertices();
			vertices.Resize(data.Read<UInt_64>());

			for (UInt_64 v = 0; v < vertices.Size(); ++v)
			{
				vertices[v].pos = data.ReadVec3<float>();
				vertices[v].normal = data.ReadVec3<float>();
				vertices[v].uv = data.ReadVec2<float>();
				vertices[v].bones = data.ReadVec4<UInt_8>();
				vertices[v].weights = data.ReadVec4<float>();
			}

			meshes[i].SetIndices(data.ReadArray<UInt_32, UInt_64>());

			/*
			Bone& skeleton = mdl->GetSkeleton();
			UInt_8 boneCount = data.Read<UInt_8>();
			for (UInt_8 b = 0; b < boneCount; ++b)
			{
				Str_8 name = data.ReadStr<Char_8, UInt_64>();
				UInt_8 parentId = data.Read<UInt_8>();
				Mat4_f localBindTrans = data.ReadMat4<float>();
				Mat4_f invBindTrans = data.ReadMat4<float>();
				if (b == 0)
				{
					skeleton = {name, b, localBindTrans, invBindTrans};
				}
				else
				{
					Bone* parent = skeleton.GetBone(parentId);
					if (!parent)
					{
						EHS_LOG_INT(LogType::ERR, 0, "Invalid bone order.");
						return false;
					}

					parent->AddBone({name, b, localBindTrans, invBindTrans});
				}
			}

			Array<Animation>& animations = mdl->GetAnimations();
			animations.Resize(data.Read<UInt_64>());

			for (UInt_64 a = 0; a < animations.Size(); ++a)
			{
				Str_8 animId = data.ReadStr<Char_8, UInt_64>();
				float duration = data.Read<float>();

				animations[a] = Animation(animId, duration, data.Read<UInt_8>());
				Array<AnimBone>& animated = animations[a].GetAnimated();
				for (UInt_8 ba = 0; ba < (UInt_8)animated.Size(); ++ba)
				{
					UInt_8 boneId = data.Read<UInt_8>();

					animated[ba] = AnimBone(boneId, data.Read<UInt_64>());
					Array<KeyFrame>& keyFrames = animated[ba].GetKeyFrames();
					for (UInt_64 kf = 0; kf < keyFrames.Size(); ++kf)
					{
						float num = data.Read<float>();
						float timeStamp = data.Read<float>();
						Vec3_f pos = data.ReadVec3<float>();
						Quat_f rot = data.ReadQuat<float>();
						Vec3_f scale = data.ReadVec3<float>();

						keyFrames[kf] = KeyFrame(num, timeStamp, pos, rot, scale);
					}
				}
			}
			*/
		}

		return true;
	}
}