#include <iostream>
using namespace std;
#include <ply.h>
#include <stdio.h>

#include "PlyParser.h"

#include "SceneGraph.h"
#include "Mesh.h"

namespace GtpVisibilityPreprocessor {

// int facesPerMesh = 100000000;
int facesPerMesh = 30;
bool useRandomMaterial = false;
bool indexVertices = true;

/* user's vertex and face definitions for a polygonal object */

typedef struct Vertex {
  int id;
  float x,y,z;
  void *other_props;       /* other properties */
} Vertex;

typedef struct PlyFace {
  int id;
  unsigned char nverts;    /* number of vertex indices in list */
  int *verts;              /* vertex index list */
  void *other_props;       /* other properties */
} PlyFace;



char *elem_names[] = { /* list of the kinds of elements in the user's object */
  "vertex", "face"
};


PlyProperty vert_props[] = { /* list of property information for a vertex */
  {"x", PLY_FLOAT, PLY_FLOAT, offsetof(Vertex,x), 0, 0, 0, 0},
  {"y", PLY_FLOAT, PLY_FLOAT, offsetof(Vertex,y), 0, 0, 0, 0},
  {"z", PLY_FLOAT, PLY_FLOAT, offsetof(Vertex,z), 0, 0, 0, 0}
};

PlyProperty face_props[] = { /* list of property information for a face */
  {"vertex_indices", PLY_INT, PLY_INT, offsetof(PlyFace,verts),
   1, PLY_UCHAR, PLY_UCHAR, offsetof(PlyFace,nverts)}
};

unsigned char has_fverts;
static PlyFace **flist;


bool
PlyParser::ParseSingleFile(const string filename,
						   SceneGraphNode *root)
{
  /*** the PLY object ***/
  int nverts;
  Vertex **vlist;
  PlyOtherElems *other_elements = NULL;
  PlyOtherProp *vert_other;
  int nelems;
  char **elist;
  int num_comments;
  char **comments;
  int num_obj_info;
  char **obj_info;
  int file_type;
  
  int i,j;
  PlyFile *ply;
  int nprops;
  int num_elems;
  PlyProperty **plist;
  char *elem_name;
  float version;
  
 
  /*** Read in the original PLY object ***/
 FILE *file = fopen(filename.c_str(), "rb");
 
 ply  = ply_read (file, &nelems, &elist);
 ply_get_info (ply, &version, &file_type);

 int nfaces;
 
 for (i = 0; i < nelems; i++) {
   
   /* get the description of the first element */
   elem_name = elist[i];
   plist = ply_get_element_description (ply, elem_name, &num_elems, &nprops);
   
   if (equal_strings ("vertex", elem_name)) {
	 
	 /* create a vertex list to hold all the vertices */
	 vlist = (Vertex **) malloc (sizeof (Vertex *) * num_elems);
	 nverts = num_elems;
	 
	 /* set up for getting vertex elements */
	 
	 ply_get_property (ply, elem_name, &vert_props[0]);
	 ply_get_property (ply, elem_name, &vert_props[1]);
	 ply_get_property (ply, elem_name, &vert_props[2]);
	 vert_other = ply_get_other_properties (ply, elem_name,
											offsetof(Vertex,other_props));
	 
	 /* grab all the vertex elements */
	 for (j = 0; j < num_elems; j++) {
	   vlist[j] = (Vertex *) malloc (sizeof (Vertex));
	   ply_get_element (ply, (void *) vlist[j]);
	   vlist[j]->id = j;
	   //	   cout<<"("<<vlist[j]->x<<","<<vlist[j]->y<<","<<vlist[j]->z<<")"<<endl;
	 }
   }
   else
	 if (equal_strings ("face", elem_name)) {
	   /* create a list to hold all the face elements */
	   ALLOCN(flist, PlyFace *, num_elems);
	   nfaces = num_elems;
	   cerr<<"num faces="<<nfaces<<endl;
	   
	   /* set up for getting face elements */
	   has_fverts = false;
	   
	   for (j=0; j<nprops; j++)
		 {
		   if (equal_strings("vertex_indices", plist[j]->name))
			 {
			   ply_get_property (ply, elem_name, &face_props[0]);
			   has_fverts = true;
			 }
		 }

	   //	   face_other = ply_get_other_properties (ply, elem_name,
	   //											  offsetof(Face,other_props));
	   
	   /* test for necessary properties */
	   if (!has_fverts) {
		 fprintf(stderr,"Faces must have vertex indices\n");
		 exit(-1);
	   }

	   /* grab all the face elements */
	   for (j = 0; j < num_elems; j++) {
		 ALLOCN(flist[j], PlyFace, 1);
		 ply_get_element (ply, (void *) flist[j]);
		 flist[j]->id = j;

		 //		 for (int k  = 0; k < flist[j]->nverts; k++) 
		 //		   cout<<flist[j]->verts[k]<<" ";
		 //		 cout<<endl;
	   }
	 } else
	   other_elements = ply_get_other_element (ply, elem_name, num_elems);


 }


 
 comments = ply_get_comments (ply, &num_comments);
 obj_info = ply_get_obj_info (ply, &num_obj_info);
 
 ply_close (ply);

 SceneGraphNode *currentNode = root;

 cerr<<"Baking faces into meshes"<<endl;

 // bake the faces into meshes
 Mesh meshProxy;
 // only one face per mesh
 VertexContainer vertices;

 for (i = 0; i < nfaces; i++) {
   if (i % facesPerMesh == 0) {
	 if (meshProxy.mFaces.size()) {

	   if (indexVertices)
		 meshProxy.IndexVertices();
	   
	   Mesh *mesh = new Mesh(meshProxy.mVertices.size(),
							 meshProxy.mFaces.size());
	   
	   
	   //	   cout<<"C="<<mesh->mVertices.capacity();
	   mesh->mVertices = meshProxy.mVertices;
	   //	   cout<<" NC="<<mesh->mVertices.capacity()<<" S="<<mesh->mVertices.size()<<endl;
	   
	   mesh->mFaces = meshProxy.mFaces;
	   
	   if (useRandomMaterial)
		 mesh->AssignRandomMaterial();

	   mesh->Preprocess();
	   // make an instance of this mesh
	   MeshInstance *mi = new MeshInstance(mesh);
	   currentNode->mGeometry.push_back(mi);
	 }

	 meshProxy.Clear();
   }
		 
   // only one face per mesh
   VertexIndexContainer vc;
   
   // add vertices
   for (int k  = 0; k < flist[i]->nverts; k++) {
	 Vertex *v = vlist[flist[i]->verts[k]];
	 vc.push_back(meshProxy.mVertices.size());
	 meshProxy.mVertices.push_back(Vector3(v->x, v->y, v->z));
   }
   
   meshProxy.mFaces.push_back(new Face(vc));
 }
 
 if (meshProxy.mFaces.size()) {

   if (indexVertices)
	 meshProxy.IndexVertices();

   Mesh *mesh = new Mesh(meshProxy.mVertices.size(),
						 meshProxy.mFaces.size());

   mesh->mVertices = meshProxy.mVertices;
   
   mesh->mFaces = meshProxy.mFaces;
   
   if (useRandomMaterial)
	 mesh->AssignRandomMaterial();
   
   mesh->Preprocess();
   // make an instance of this mesh
   MeshInstance *mi = new MeshInstance(mesh);
   currentNode->mGeometry.push_back(mi);
 }

 // make sure that no face gets deleted by the destructor!
 meshProxy.Clear();

 for (i=0; i < nverts; i++)
   free(vlist[i]);

 free(vlist);

 for (i=0; i < nfaces; i++)
   free(flist[i]);

 free(flist);
 
 
 return true;


}

bool
PlyParser::ParseFile(const string filename,
					 SceneGraphNode **root,
					 const bool loadPolygonsAsMeshes,
					 vector<Intersectable *> *parents)
{
  vector<string> filelist;
  
  if (strstr(filename.c_str(), ".plb")) {
	// parse the filelist
	FILE *f = fopen(filename.c_str(), "rt");
	char s[64];
	if (!f) {
	  cerr<<"Cannot open .plb file"<<endl;
	  exit(1);
	}
	while (fgets(s,64,f)) {
	  // remove nl
	  s[strlen(s)-1] = 0;
	  filelist.push_back(s);
	}
	fclose(f);

  } else
	filelist.push_back(filename);

  *root = new SceneGraphNode;

  for (int i=0; i < filelist.size(); i++) {
	if (!ParseSingleFile(filelist[i], *root)) {
	  cerr<<"Ply parse error. Quiting ...\n";
	  exit(1);
	}
  }
  return true;
}

}