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

namespace ehs
{
	Mesh::Mesh()
		: hashId(0)
    {
		AddType("Mesh");
    }

	Mesh::Mesh(Str_8 id, Array<Vertex_f> vertices, Array<UInt_32> indices)
        : hashId(id.Hash_64()), id((Str_8&&)id), vertices((Array<Vertex_f>&&)vertices),
		indices((Array<UInt_32>&&)indices)
    {
		AddType("Mesh");
    }

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

	Mesh::Mesh(Mesh&& mesh) noexcept
		: BaseObj((BaseObj&&)mesh), hashId(mesh.hashId), id((Str_8&&)mesh.id), vertices((Array<Vertex_f>&&)mesh.vertices),
		indices((Array<UInt_32>&&)mesh.indices)
	{
		mesh.hashId = 0;
	}

	Mesh::Mesh(const Mesh& mesh)
		: BaseObj(mesh), hashId(mesh.hashId), id(mesh.id), vertices(mesh.vertices), indices(mesh.indices)
	{
	}

	Mesh& Mesh::operator=(Mesh&& mesh) noexcept
	{
		if (this == &mesh)
			return *this;

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

		hashId = mesh.hashId;
		id = (Str_8&&)mesh.id;
		vertices = (Array<Vertex_f>&&)mesh.vertices;
		indices = (Array<UInt_32>&&)mesh.indices;

		mesh.hashId = 0;

		return *this;
	}

	Mesh& Mesh::operator=(const Mesh& mesh)
	{
		if (this == &mesh)
			return *this;

		BaseObj::operator=(mesh);

		hashId = mesh.hashId;
		id = mesh.id;
		vertices = mesh.vertices;
		indices = mesh.indices;

		return *this;
	}

	void Mesh::Release()
	{
		vertices.Clear();
		indices.Clear();
	}

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

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

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

    void Mesh::SetVertices(const Array<Vertex_f>& newVertices)
    {
        vertices = newVertices;
    }

    const Array<Vertex_f>& Mesh::GetVertices() const
    {
        return vertices;
    }

    Array<Vertex_f>& Mesh::GetVertices()
    {
        return vertices;
    }

    void Mesh::SetIndices(const Array<UInt_32>& newIndices)
    {
        indices = newIndices;
    }

    bool Mesh::HasIndices() const
    {
        return indices.Size();
    }

    const Array<UInt_32>& Mesh::GetIndices() const
    {
        return indices;
    }

    Array<UInt_32>& Mesh::GetIndices()
    {
        return indices;
    }

	void Mesh::Calculate()
	{
		if (indices.Size())
			for (UInt_64 i = 0; i < indices.Size(); i += 3)
				Calculate(vertices[indices[i]], vertices[indices[i + 1]], vertices[indices[i + 2]]);
		else
			for (UInt_64 i = 0; i < vertices.Size(); i += 3)
				Calculate(vertices[i], vertices[i + 1], vertices[i + 2]);
	}

	void Mesh::Calculate(Vertex_f& vert1, Vertex_f& vert2, Vertex_f& vert3)
	{
		Vec3_f edge1 = vert2.pos - vert1.pos;
		Vec3_f edge2 = vert3.pos - vert1.pos;
		Vec2_f deltaUV1 = vert2.uv - vert1.uv;
		Vec2_f deltaUV2 = vert3.uv - vert1.uv;

		float f = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV2.x * deltaUV1.y);

		Vec3_f tan(
			f * (deltaUV2.y * edge1.x - deltaUV1.y * edge2.x),
			f * (deltaUV2.y * edge1.y - deltaUV1.y * edge2.y),
			f * (deltaUV2.y * edge1.z - deltaUV1.y * edge2.z)
		);

		vert1.tan = tan;
		vert2.tan = tan;
		vert3.tan = tan;

		Vec3_f bTan(
			f * (-deltaUV2.x * edge1.x + deltaUV1.x * edge2.x),
			f * (-deltaUV2.x * edge1.y + deltaUV1.x * edge2.y),
			f * (-deltaUV2.x * edge1.z + deltaUV1.x * edge2.z)
		);

		vert1.bTan = bTan;
		vert2.bTan = bTan;
		vert3.bTan = bTan;
	}
}