#pragma once

#include <set>
#include <map>
#include <vector>
#include <list>
#include <iostream>
#include <simplif.h>
#include <GeoMeshSimplifier.h>

using	namespace	Geometry;
using	namespace	std;

//-------------------------------------------------------------------------
// Class to create a map without repeated vertices
//-------------------------------------------------------------------------
class _float3_
{
	public:

		float x,y,z;

		_float3_(float x=0.0f, float y=0.0f, float z=0.0f)
		{
			this->x = x; this->y = y; this->z = z;
		}

		_float3_(const _float3_ &f)
		{
			x=f.x; y=f.y; z=f.z;
		}

		_float3_ & operator=(const _float3_ &f)
		{
			x=f.x; y=f.y; z=f.z; return *this;
		}

		bool operator<(const _float3_ &f) const
		{
			if (x<f.x) return true;
			if (x>f.x) return false;
			if (y<f.y) return true;
			if (y>f.y) return false;
			if (z<f.z) return true;
			if (z>f.z) return false;
			return false;
		}
};

//-------------------------------------------------------------------------
// Class to perform mesh simplification.
//-------------------------------------------------------------------------
class SimplificationMethod
{
	private:

		Geometry::Mesh	*mGeoMesh;

		void compute_pair_info(simplif::pair_info*);

		simplif::Model M0;

		simplif::buffer<simplif::vert_info> vinfo;

		simplif::Heap *heap;
		simplif::real proximity_limit;    // distance threshold squared

		int initialVertCount;
		int initialEdgeCount;
		int initialFaceCount;

		//	Simplification sequence.
		MeshSimplificationSequence	*msimpseq;

		//	Stores the simplification step.
		MeshSimplificationSequence::Step simplifstep;

		inline simplif::vert_info& vertex_info(simplif::Vertex *v)
		{
			return vinfo(v->validID());
		}

		simplif::real pair_mesh_penalty(simplif::Model& M,
				simplif::Vertex *v1,
				simplif::Vertex *v2,
				simplif::Vec3& vnew);

		int predict_face(simplif::Face& F,
				simplif::Vertex *v1,
				simplif::Vertex *v2,
				simplif::Vec3& vnew,
				simplif::Vec3& f1,
				simplif::Vec3& f2,
				simplif::Vec3& f3);

		bool check_for_pair(simplif::Vertex *v0, simplif::Vertex *v1);

		simplif::pair_info *new_pair(simplif::Vertex *v0, simplif::Vertex *v1);

		void delete_pair(simplif::pair_info *pair);

		void do_contract(simplif::Model& m, simplif::pair_info *pair);

		bool decimate_quadric(simplif::Vertex *v, simplif::Mat4& Q);

		void decimate_contract(simplif::Model& m);

		simplif::real decimate_error(simplif::Vertex *v);

		simplif::real decimate_min_error();

		simplif::real decimate_max_error(simplif::Model& m);

		void decimate_init(simplif::Model& m, simplif::real limit);

		bool pair_is_valid(simplif::Vertex *u, simplif::Vertex *v);

		void simplifmethod_run(int,	Geometry::TIPOFUNC	upb=0);

		void simplifmethod_runv(int,	Geometry::TIPOFUNC	upb=0);

		void simplifmethod_init(void);

		//	To map the mesh with de simplification method structure.
		//	Submeshes which pertains each vertex.
		std::map< int,	std::vector<int> > submeshmap;

		//	Vertices of the VertexBuffer that point
		//	at this vertex of the simplification method.
		std::map< int,	std::vector<int> > vertexbuffermap;

		//	Multimap to store current vertex in a simplification state.
		typedef	multimap<_float3_,	int>	vertex_map;
		typedef	vertex_map::iterator			vertex_map_str;
		typedef	vertex_map::value_type		vertex_pair;

		//	Store unique vertices by submesh (without repetitions).
		typedef std::map<int,int> MAPAINDIND;

		//	Store all the indices by submesh (with repetitions).
		typedef std::vector<int> REPINDLIST;

		vertex_map	vertexMultimap;

		//	Simplification sequence of the simplification method.
		std::vector<Geometry::MeshSimplificationSequence::Step> decim_data;

		std::string meshName;

		unsigned int *first_index_submesh;

		//std::vector<simplif::pair_info *> pointers_to_remove;

		int indexMeshLeaves;

		//	Contract lonely vertices that have same coords 
		//	than the contracted one.
		void	contractLonelyVertices(	simplif::Model	&m,
																	simplif::Vertex	*v0,
																	simplif::Vertex *v1,
																	simplif::Vec3		candidate);

		//	Find twin vertices to the contracted one and contract them.
		void	removeTwinVertices(	simplif::Model	&m,
															simplif::Vertex	*v0,
															simplif::Vertex	*v1,
															simplif::Vec3		candidate);

		void	fillUpSharedVertices(	MAPAINDIND	&shared_vertex_map,
																REPINDLIST *ver_inds_rep_by_geo);

		void	fillUpVertices(	MAPAINDIND	*unique_verts_inds_by_geo,
													REPINDLIST *ver_inds_rep_by_geo);

		void	addNewBoneAssignments();

		void	eraseVoidSubMeshes(Mesh	*geoMesh);

	public:

		Mesh *mInitialMesh;

		//	Total number of triangles of all the submeshes.
		int number_of_triangles;

		///	Constructor.
		SimplificationMethod(const Mesh *m);

		///	Destructor.
		~SimplificationMethod();

		void	generateSimplifModel(void);

		MeshSimplificationSequence *Decimate(	float			lod,
																					int				simpliftype,
																					TIPOFUNC	upb=0);

		void setMeshLeaves(int meshLeaves);

		///	Gets mesh simplified.
		Mesh	*	GetMesh();

};