/*
 *  mesh_loader.cpp
 *  ACCtessellator
 *
 *  Created by Denis Kovacs on 8/9/08.
 *  Copyright 2008 NYU. All rights reserved.
 *
 */
#include <iostream>
#include <string>
#include <cstring>
#include <fstream>
#include <vector>
#include <map>
#include <exception>
#include "mesh_loader.h"
#include "cvec3t.h"
#include "cvec2t.h"


using namespace std;

#define NO_VTX (unsigned int)(-1)

typedef CVec3T<float> Vec3;
typedef CVec2T<float> Vec2;



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

// triple of indices used per vertex of a face: 
//the index of vertex position, the index of vertex texture coords (uv), 
// and the index of normal
struct VTXindex
{
	int posIdx;
	int uvIdx;
	int norIdx;
        
	VTXindex( int p, int uv, int n): posIdx(p), uvIdx(uv), norIdx(n) {}
	VTXindex() {}
};


struct OBJMesh 
{
	vector<Vec3> pos;
	vector<Vec2> uv;
	vector<Vec3> nor;
        // triple of indices for each face vertex
	vector<VTXindex>  faces;
        // indices in array faces  where faces start
        vector<unsigned int>  face_startidx; 	
	bool hasTextureCoords() { return uv.size() != 0; }
	bool hasNormals() { return nor.size() != 0; }
};


struct VTXindex_ltstr
{
	bool operator()(VTXindex v1, VTXindex v2) const
	{
		if (v1.posIdx != v2.posIdx) return v1.posIdx<v2.posIdx;
		if (v1.uvIdx  != v2.uvIdx) return v1.uvIdx<v2.uvIdx;
		return v1.norIdx<v2.norIdx;
	}
};

typedef map<VTXindex, int, VTXindex_ltstr> VTXmap;

//------------------------------------------------------------------
static void skipLine(istream& ifs);
static bool skipCommentLine(istream& ifs);


// ripped from TooL

struct OBJMesh* readOBJ(const char *filename)
//------------------------------------------------------------------
{
        OBJMesh*  mesh = new OBJMesh;
	
	string ele_id;
	float x, y, z;
	
	ifstream ifs( filename );
	if (!ifs) {
		printf("failed to open %s\n", filename);
		return mesh;
	}
	while(skipCommentLine(ifs)) 
	{
        	if (!(ifs >> ele_id)) return mesh;
		
		if ("v" == ele_id)            // position
		{
			ifs >> x >> y >> z;
			mesh->pos.push_back(Vec3(x, y, z));
		}
		else if ("vt" == ele_id) 	  // uv coordinates
		{
			ifs >> x >> y >> z;
			ifs.clear();                // is z (i.e. w) is not available, have to clear error flag.
			mesh->uv.push_back(Vec2(x, y));
		}
		else if ("vn" == ele_id)      // normal
		{	
			ifs >> x >> y >> z;
			
			if(!ifs.good()) 
			{                         // in case it is -1#IND00
				x = y = z = 0.0;
				ifs.clear();
				skipLine(ifs);
			}
			mesh->nor.push_back(Vec3(x, y, z));
		}
		else if ("f" == ele_id) //	face data
		{	
			// record face size
			mesh->face_startidx.push_back(mesh->faces.size());
			// read in all vertices of a face
			vector<VTXindex> indices;
			while ( ifs.good() )
			{
				char c;
				VTXindex v = VTXindex(NO_VTX, NO_VTX, NO_VTX);
				if(!mesh->hasTextureCoords() && !mesh->hasNormals())
					ifs >> v.posIdx;
				else if(!mesh->hasTextureCoords())
					ifs >> v.posIdx >> c >> c >> v.norIdx;
				else if(!mesh->hasNormals())
					ifs >> v.posIdx >> c >> v.uvIdx;
				else
					ifs >> v.posIdx >> c >> v.uvIdx >> c >>  v.norIdx;
				if ( ifs.good() ) indices.push_back(v);
			}

			for (size_t k=0; k< indices.size(); k++)
			{
			  mesh->faces.push_back(indices[k]);				
			}	

			ifs.clear();
		}
		else
			skipLine(ifs);
		
	}	
		
	ifs.close();
	
	return mesh;
}




static void skipLine(istream& ifs)
{
    char next;
	ifs >> std::noskipws;
    while( (ifs >> next) && ('\n' != next) );
}

static bool skipCommentLine(istream& ifs)
{
	char next;
	while( ifs >> std::skipws >> next ) 
    {
		ifs.putback(next);
		if ('#' == next)
			skipLine(ifs);
		else
			return true;
    }
    return false;
}


void dumpMeshVerbose(const OBJMesh& mesh)
//------------------------------------------------------------------
{
	int nV;
	unsigned int i,j;

	printf("#nV:%d nF:%d",
	       mesh.pos.size(), mesh.face_startidx.size());
	
	printf(" Pos:\n");
	nV = 0;
	for(i=0; i<mesh.pos.size(); i++ )
	  {
	    printf("#%4d: \n",i);
            printf("v %f %f %f\n", mesh.pos[nV].x(),mesh.pos[nV].y(),mesh.pos[nV].z() ); nV++;
	  }
	
	if (mesh.uv.size() > 0 )
	{
		printf("# UV:\n");
		nV = 0;
		for(i=0; i<mesh.uv.size(); i++ )
		{
			printf("#%4d: \n",i);
			printf("vt %f %f\n", mesh.uv[nV].x(),mesh.uv[nV].y()); nV++;
		}
	}
	
	if (mesh.nor.size() > 0 )
	{
		printf("# Nor:\n");
		nV = 0;
		for(i=0; i<mesh.nor.size(); i++)
		{			printf("#%4d: ",i);
			printf("vn %f %f %f\n", mesh.nor[nV].x(),mesh.nor[nV].y(),mesh.nor[nV].z() ); nV++;
		}
	}
	
	if (mesh.faces.size() )
	{
		printf("# Faces:\n");
		nV = 0;
		for(i=0; i<mesh.face_startidx.size(); i++)
		{
			printf("# %4d: \nf ",i);
			unsigned int endidx = 0; 
			if (i < mesh.face_startidx.size()-1) endidx = mesh.face_startidx[i+1]; else endidx = mesh.faces.size();
			for(j=mesh.face_startidx[i]; j< endidx; j++ )
			{
				printf("%4d ", mesh.faces[nV].posIdx); 
				if( mesh.faces[nV].uvIdx != NO_VTX) printf("/%4d ", mesh.faces[nV].uvIdx); 
				if( mesh.faces[nV].norIdx != NO_VTX) printf("/%4d ", mesh.faces[nV].norIdx); 
				nV++;
			}
			printf("\n");
		}
	}
}