#pragma once

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

using	namespace	Geometry;

class SimplificationMethod
{
	private:

		Geometry::Mesh	*mGeoMesh;

		void compute_pair_info(simplif::pair_info*);

		simplif::Model M0;

		simplif::array<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;

		//	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);

		//	Remove twin edges.
		void	removeTwinEdges(simplif::Model	&m,
													simplif::Vertex	*v0,
													simplif::Vertex	*v1,
													simplif::Vec3		candidate);

	public:

		const Geometry::Mesh *objmesh;

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

		SimplificationMethod(const Geometry::Mesh *m);

		void	generateSimplifModel(void);

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

		void setMeshLeaves(int meshLeaves);

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

		///	Destructor.
		~SimplificationMethod();
};