// TnzCore includes

#include "tstream.h"

// tcg includes

#include "tcg/tcg_misc.h"

#include "tcg/tcg_iterator_ops.h"

#define INCLUDE_HPP

#include "tmeshimage.h"

#undef INCLUDE_HPP

//******************************************************************************

//    Explicit instantiations

//******************************************************************************

template class DV_EXPORT_API tcg::Vertex<tpointd>;</tpointd>

template class DV_EXPORT_API tcg::Mesh<ttexturevertex, tcg::edge,="" tcg::facen<3="">>;</ttexturevertex,>

template class DV_EXPORT_API tcg::TriMesh<ttexturevertex, tcg::edge,="" tcg::facen<3="">>;</ttexturevertex,>

typedef tcg::TriMesh<ttexturevertex, tcg::edge,="" tcg::facen<3="">> TriMesh_base;</ttexturevertex,>

//******************************************************************************

//    TTextureMesh  implementation

//******************************************************************************

DEFINE_CLASS_CODE(TTextureMesh, 120)

PERSIST_IDENTIFIER(TTextureMesh, "mesh")

static TTextureMeshP cloneMesh_(const TTextureMeshP &other)

{

	return TTextureMeshP(new TTextureMesh(*other));

}

void static_check()

{

	/* input iterator */

	static_assert(std::is_same<std::iterator_traits<std::vector<ttexturemesh>::iterator>::iterator_category, std::random_access_iterator_tag>::value == true, "random");</std::iterator_traits<std::vector<ttexturemesh>

	static_assert(std::is_base_of<std::input_iterator_tag, std::iterator_traits<std::vector<ttexturemesh="">::iterator>::iterator_category>::value == true, "input");</std::input_iterator_tag,>

	static_assert(std::is_base_of<std::forward_iterator_tag, std::iterator_traits<std::vector<ttexturemesh="">::iterator>::iterator_category>::value == true, "forward");</std::forward_iterator_tag,>

	static_assert(std::is_constructible

										std::iterator_traits<std::vector<ttexturemeshp>::iterator>::reference>::value == true,</std::vector<ttexturemeshp>

				  "akan");

	/* converted iterator */

	std::vector<ttexturemeshp> vec;</ttexturemeshp>

	auto it = vec.end();

	auto c = tcg::make_cast_it(it, cloneMesh_);

	static_assert(std::is_same<std::iterator_traits<decltype(c)>::iterator_category, std::random_access_iterator_tag>::value == true, "random");</std::iterator_traits<decltype(c)>

	static_assert(std::is_base_of<std::input_iterator_tag, std::iterator_traits<decltype(c)="">::iterator_category>::value == true, "input");</std::input_iterator_tag,>

	static_assert(std::is_base_of<std::forward_iterator_tag, std::iterator_traits<decltype(c)="">::iterator_category>::value == true, "forward");</std::forward_iterator_tag,>

	//TTextureMeshP p(std::iterator_traits< decltype(c) >::reference);

	static_assert(std::is_constructible

										std::iterator_traits<decltype(c)>::reference>::value == true,</decltype(c)>

				  "akan");

}

//-----------------------------------------------------------------------

TTextureMesh::TTextureMesh()

	: TSmartObject(m_classCode)

{

}

//-----------------------------------------------------------------------

TTextureMesh::TTextureMesh(const TTextureMesh &other)

	: TriMesh_base(other), TSmartObject(m_classCode)

{

}

//-----------------------------------------------------------------------

TTextureMesh &TTextureMesh::operator=(const TTextureMesh &other)

{

	TriMesh_base::operator=(other);

	return *this;

}

//-----------------------------------------------------------------------

bool TTextureMesh::faceContains(int f, const TPointD &p) const

{

	int v0, v1, v2;

	this->faceVertices(f, v0, v1, v2);

	const TPointD &p0 = vertex(v0).P();

	const TPointD &p1 = vertex(v1).P();

	const TPointD &p2 = vertex(v2).P();

	bool clockwise = (tcg::point_ops::cross(p2 - p0, p1 - p0) >= 0);

	return ((tcg::point_ops::cross(p - p0, p1 - p0) >= 0) == clockwise) &&

		   ((tcg::point_ops::cross(p - p1, p2 - p1) >= 0) == clockwise) &&

		   ((tcg::point_ops::cross(p - p2, p0 - p2) >= 0) == clockwise);

}

//-----------------------------------------------------------------------

int TTextureMesh::faceContaining(const TPointD &p) const

{

	int f, fCount = facesCount();

	for (f = 0; f < fCount; ++f)

		if (faceContains(f, p))

			return f;

	return -1;

}

//-----------------------------------------------------------------------

TRectD TTextureMesh::getBBox() const

{

	// TODO: Should be cached...

	const double max = (std::numeric_limits<double>::max)();</double>

	TRectD result(max, max, -max, -max);

	// Iterate all meshes

	assert(m_vertices.size() == m_vertices.nodesCount());

	int v, vCount = int(m_vertices.size());

	for (v = 0; v != vCount; ++v) {

		const TTextureVertex &vx = m_vertices[v];

		result.x0 = tmin(result.x0, vx.P().x);

		result.y0 = tmin(result.y0, vx.P().y);

		result.x1 = tmax(result.x1, vx.P().x);

		result.y1 = tmax(result.y1, vx.P().y);

	}

	return result;

}

//-----------------------------------------------------------------------

void TTextureMesh::saveData(TOStream &os)

{

	struct locals {

		static inline bool hasNon1Rigidity(const TTextureMesh &mesh)

		{

			int v, vCount = int(mesh.verticesCount());

			for (v = 0; v != vCount; ++v)

				if (mesh.vertex(v).P().rigidity != 1.0)

					return true;

			return false;

		}

	};

	// NOTE: Primitives saved by INDEX iteration is NOT COINCIDENTAL - since

	// the lists' internal linking could have been altered to mismatch the

	// natural indexing referred to by primitives' data.

	if (m_vertices.size() != m_vertices.nodesCount() ||

		m_edges.size() != m_edges.nodesCount() ||

		m_faces.size() != m_faces.nodesCount()) {

		// Ensure the mesh is already squeezed - save a squeezed

		// copy if necessary

		TTextureMesh mesh(*this);

		mesh.squeeze();

		mesh.saveData(os);

		return;

	}

	assert(m_vertices.size() == m_vertices.nodesCount());

	assert(m_edges.size() == m_edges.nodesCount());

	assert(m_faces.size() == m_faces.nodesCount());

	// Store Vertices

	os.openChild("V");

	{

		int vCount = int(m_vertices.size());

		os << vCount;

		for (int v = 0; v != vCount; ++v) {

			TTextureMesh::vertex_type &vx = m_vertices[v];

			os << vx.P().x << vx.P().y;

		}

	}

	os.closeChild();

	// Store Edges

	os.openChild("E");

	{

		int eCount = int(m_edges.size());

		os << eCount;

		for (int e = 0; e != eCount; ++e) {

			TTextureMesh::edge_type &ed = m_edges[e];

			os << ed.vertex(0) << ed.vertex(1);

		}

	}

	os.closeChild();

	// Store Faces

	os.openChild("F");

	{

		int fCount = int(m_faces.size());

		os << fCount;

		for (int f = 0; f != fCount; ++f) {

			TTextureMesh::face_type &fc = m_faces[f];

			int e, eCount = fc.edgesCount();

			for (e = 0; e < eCount; ++e)

				os << fc.edge(e);

		}

	}

	os.closeChild();

	// Store rigidities

	if (locals::hasNon1Rigidity(*this)) {

		os.openChild("rigidities");

		{

			int vCount = int(m_vertices.size());

			os << vCount;

			for (int v = 0; v != vCount; ++v)

				os << m_vertices[v].P().rigidity;

		}

		os.closeChild();

	}

}

//-----------------------------------------------------------------------

void TTextureMesh::loadData(TIStream &is)

{

	typedef tcg::Mesh<vertex_type, edge_type,="" face_type=""> mesh_type;</vertex_type,>

	std::string str;

	int i, size;

	while (is.openChild(str)) {

		if (str == "V") {

			is >> size;

			m_vertices.reserve(size);

			TTextureMesh::vertex_type v;

			for (i = 0; i < size; ++i) {

				is >> v.P().x >> v.P().y;

				mesh_type::addVertex(v);

			}

			is.closeChild();

		} else if (str == "E") {

			is >> size;

			m_edges.reserve(size);

			int v0, v1;

			for (i = 0; i < size; ++i) {

				is >> v0 >> v1;

				mesh_type::addEdge(TTextureMesh::edge_type(v0, v1));

			}

			is.closeChild();

		} else if (str == "F") {

			is >> size;

			m_faces.reserve(size);

			int e[3];

			for (i = 0; i < size; ++i) {

				is >> e[0] >> e[1] >> e[2];

				mesh_type::addFace(TTextureMesh::face_type(e));

			}

			is.closeChild();

		} else if (str == "rigidities") {

			is >> size;

			size = tmin(size, this->verticesCount());

			for (i = 0; i < size; ++i)

				is >> m_vertices[i].P().rigidity;

			is.closeChild();

		} else {

			assert(false);

			is.skipCurrentTag();

		}

	}

}

//******************************************************************************

//    TMeshImage::Imp  definition

//******************************************************************************

class TMeshImage::Imp

{

public:

	std::vector<ttexturemeshp> m_meshes; //!< Mesh data</ttexturemeshp>

	double m_dpiX, m_dpiY;				 //!< Meshes dpi

	Imp() : m_dpiX(), m_dpiY() {}

	Imp(const Imp &other)

		: m_meshes(tcg::make_cast_it(other.m_meshes.begin(), cloneMesh),

				   tcg::make_cast_it(other.m_meshes.end(), cloneMesh)),

		  m_dpiX(other.m_dpiX), m_dpiY(other.m_dpiY) {}

private:

	static TTextureMeshP cloneMesh(const TTextureMeshP &other)

	{

		return TTextureMeshP(new TTextureMesh(*other));

	}

	// Not assignable

	Imp &operator=(const Imp &other);

};

//******************************************************************************

//    TMeshImage  implementation

//******************************************************************************

TMeshImage::TMeshImage()

	: m_imp(new Imp)

{

}

//-----------------------------------------------------------------------

TMeshImage::TMeshImage(Imp *imp)

	: m_imp(imp)

{

}

//-----------------------------------------------------------------------

TMeshImage::~TMeshImage()

{

	delete m_imp;

}

//-----------------------------------------------------------------------

TMeshImage::TMeshImage(const TMeshImage &other)

	: m_imp(new Imp(*other.m_imp))

{

}

//-----------------------------------------------------------------------

TMeshImage &TMeshImage::operator=(TMeshImage other)

{

	swap(*this, other);

	return *this;

}

//-----------------------------------------------------------------------

TRectD TMeshImage::getBBox() const

{

	const double max = (std::numeric_limits<double>::max)();</double>

	TRectD result(max, max, -max, -max);

	// Iterate all meshes

	int m, mCount = int(m_imp->m_meshes.size());

	for (m = 0; m < mCount; ++m)

		result += m_imp->m_meshes[m]->getBBox();

	return result;

}

//-----------------------------------------------------------------------

TImage *TMeshImage::cloneImage() const

{

	return new TMeshImage(*this);

}

//-----------------------------------------------------------------------

void TMeshImage::getDpi(double &dpix, double &dpiy) const

{

	dpix = m_imp->m_dpiX, dpiy = m_imp->m_dpiY;

}

//-----------------------------------------------------------------------

void TMeshImage::setDpi(double dpix, double dpiy)

{

	m_imp->m_dpiX = dpix, m_imp->m_dpiY = dpiy;

}

//-----------------------------------------------------------------------

const std::vector<ttexturemeshp> &TMeshImage::meshes() const</ttexturemeshp>

{

	return m_imp->m_meshes;

}

//-----------------------------------------------------------------------

std::vector<ttexturemeshp> &TMeshImage::meshes()</ttexturemeshp>

{

	return m_imp->m_meshes;

}