#include <windows.h>
#include <gl/glut.h>
#include <list>
#include <iostream>
#include <fstream>
#include <cmath>
#include <string>
#include "model.h"

#define lefteyeX -32.0f
#define lefteyeY 36.0f
#define lefteyeZ 34.0f
#define righteyeX +34.0f
#define righteyeY 37.0f
#define righteyeZ 33.0f

using namespace std;


model::model(string file){
	char buffer[256];
	float max=0.0;
	float min=0.0;

	cout<<file.c_str()<<" loading"<<endl;
	file.append(".verts");
	ifstream coor(file.c_str(),ifstream::in);

	coor.getline(buffer,256);
	order=atoi(buffer)*3;
	points=new GLfloat[order];
	translated=new GLfloat[order];
	vertnames=new string[order/3];
	jawVerts=new bool[order/3];
	lowerlipVerts=new bool[order/3];
	upperlipVerts=new bool[order/3];
	leftbrowVerts=new bool[order/3];
	rightbrowVerts=new bool[order/3];
	for(int i=0;i<order;){
		coor.getline(buffer,256);
		strtok(buffer," ");
		vertnames[i/3]="";
		jawVerts[i/3]=false;
		lowerlipVerts[i/3]=false;
		upperlipVerts[i/3]=false;
		leftbrowVerts[i/3]=false;
		rightbrowVerts[i/3]=false;
		for(int j=0;j<3;j++){
			points[i]=atof(strtok(NULL," "));		// x, y, and z values
			translated[i]=points[i];
			i++;
		}
	}
	size=1;
	coor.close();
	matrix[0]=matrix[5]=matrix[10]=matrix[15]=1;
	matrix[1]=matrix[2]=matrix[3]=matrix[4]=0;
	matrix[6]=matrix[7]=matrix[8]=matrix[9]=0;
	matrix[11]=matrix[12]=matrix[13]=matrix[14]=0;
	scale(size, size, size);
	reset();

	string::iterator end=file.end();
	file.replace(end-5,end,"polys");
	ifstream poly(file.c_str(),ifstream::in);

	poly.getline(buffer,256);
	P=atoi(buffer);
	lines=new int*[P];
	polynames=new string[P];
	float *polyNorms=new GLfloat[P*3];
	for(int i=0;i<P;i++){
		poly.getline(buffer,256);
		string str(buffer);
		int count=0;
		size_t found=str.find_first_of(" ");
		while (found!=string::npos){				//find out number of vertices in polygon
		  found=str.find_first_of(" ",found+1);		
		  count++;
		}
		lines[i]=new int[count+1];
		lines[i][0]=count;
		polynames[i]=strtok(buffer," ");
		for(int j=1;j<=count;j++){
			lines[i][j]=atoi(strtok(NULL,"/"));		//read in vertices
			if(vertnames[lines[i][j]-1].compare("leftbrow")==0)leftbrowVerts[lines[i][j]-1]=true;
			if(vertnames[lines[i][j]-1].compare("rightbrow")==0)rightbrowVerts[lines[i][j]-1]=true;
			if(vertnames[lines[i][j]-1].compare("jaw")==0) jawVerts[lines[i][j]-1]=true;
			if(vertnames[lines[i][j]-1].compare("upperlip")==0)upperlipVerts[lines[i][j]-1]=true;
			if(vertnames[lines[i][j]-1].compare("lowerlip")==0) lowerlipVerts[lines[i][j]-1]=true;
			if(vertnames[lines[i][j]-1].compare("")==0||vertnames[lines[i][j]-1].compare(polynames[i])==0){
				vertnames[lines[i][j]-1]=polynames[i];
			}else{
				vertnames[lines[i][j]-1]="border";
			}
			strtok(NULL," ");
		}
		GLfloat p1[3]={points[(lines[i][1]-1)*3],points[(lines[i][1]-1)*3+1],points[(lines[i][1]-1)*3+2]};
		GLfloat p2[3]={points[(lines[i][2]-1)*3],points[(lines[i][2]-1)*3+1],points[(lines[i][2]-1)*3+2]};
		GLfloat p3[3]={points[(lines[i][3]-1)*3],points[(lines[i][3]-1)*3+1],points[(lines[i][3]-1)*3+2]};
		GLfloat p4[3];
		p4[0]=(p1[2]-p2[2])*(p3[1]-p2[1])-(p1[1]-p2[1])*(p3[2]-p2[2]);
		p4[1]=(p1[0]-p2[0])*(p3[2]-p2[2])-(p1[2]-p2[2])*(p3[0]-p2[0]);
		p4[2]=(p1[1]-p2[1])*(p3[0]-p2[0])-(p1[0]-p2[0])*(p3[1]-p2[1]);
		GLfloat len=(GLfloat)(sqrt(p4[0]*p4[0] + p4[1]*p4[1] + p4[2]*p4[2]));
		if(len>0){
			p4[0]/=len;
			p4[1]/=len;
			p4[2]/=len;
		}
		polyNorms[i*3]=p4[0];
		polyNorms[i*3+1]=p4[1];
		polyNorms[i*3+2]=p4[2];
	}
	vertNorms=new GLfloat[order];
	int* adjFaces=new int[order/3];
	for(int i=0;i<order/3;i++){
		adjFaces[i]=vertNorms[i*3]=vertNorms[i*3+1]=vertNorms[i*3+2]=0;
	}
	for(int i=0;i<P;i++){					//add the adjacent face normals
		for(int j=1;j<=lines[i][0];j++){
			vertNorms[(lines[i][j]-1)*3]+=polyNorms[i*3];
			vertNorms[(lines[i][j]-1)*3+1]+=polyNorms[i*3+1];
            vertNorms[(lines[i][j]-1)*3+2]+=polyNorms[i*3+2];
			adjFaces[lines[i][j]-1]++;
		}
	}
	for(int i=0;i<order/3;i++){				//divide by the number of adjacent faces
		if(adjFaces[i]>0){
			vertNorms[i*3]/=adjFaces[i];
			vertNorms[i*3+1]/=adjFaces[i];
			vertNorms[i*3+2]/=adjFaces[i];
		}
	}
	poly.close();

	end=file.end();
	file.erase(end-6,end);
	initMatrices();
	initFFD();
	/*
	ofstream tempFI("out.txt");
	tempFI<<order/3<<";"<<endl;
	for(int i=0;i<order/3;i++){
		tempFI<<vertnames[i]<<" "<<points[3*i]<<" "<<points[3*i+1]<<" "<<points[3*i+2]<<endl;
	}
	*/
}

void model::initMatrices(){
	glLoadIdentity();
	glGetFloatv(GL_MODELVIEW_MATRIX, eyeM);
}

void model::initFFD(){
	rightbrowI[0][0]=rightbrow[0][0]=-50.0f;
	rightbrowI[0][1]=rightbrow[0][1]=55.0f;
	rightbrowI[0][2]=rightbrow[0][2]=40.0f;
	rightbrowI[1][0]=rightbrow[1][0]=-40.0f;
	rightbrowI[1][1]=rightbrow[1][1]=60.0f;
	rightbrowI[1][2]=rightbrow[1][2]=45.0f;
	rightbrowI[2][0]=rightbrow[2][0]=-20.0f;
	rightbrowI[2][1]=rightbrow[2][1]=60.0f;
	rightbrowI[2][2]=rightbrow[2][2]=55.0f;
	rightbrowI[3][0]=rightbrow[3][0]=-10.0f;
	rightbrowI[3][1]=rightbrow[3][1]=50.0f;
	rightbrowI[3][2]=rightbrow[3][2]=60.0f;

	leftbrowI[0][0]=leftbrow[0][0]=50.0f;
	leftbrowI[0][1]=leftbrow[0][1]=55.0f;
	leftbrowI[0][2]=leftbrow[0][2]=40.0f;
	leftbrowI[1][0]=leftbrow[1][0]=40.0f;
	leftbrowI[1][1]=leftbrow[1][1]=60.0f;
	leftbrowI[1][2]=leftbrow[1][2]=45.0f;
	leftbrowI[2][0]=leftbrow[2][0]=20.0f;
	leftbrowI[2][1]=leftbrow[2][1]=60.0f;
	leftbrowI[2][2]=leftbrow[2][2]=55.0f;
	leftbrowI[3][0]=leftbrow[3][0]=10.0f;
	leftbrowI[3][1]=leftbrow[3][1]=50.0f;
	leftbrowI[3][2]=leftbrow[3][2]=60.0f;

	upperlipI[0][0]=upperlip[0][0]=-24.0f;
	upperlipI[0][1]=upperlip[0][1]=-30.0f;
	upperlipI[0][2]=upperlip[0][2]=80.0f;
	upperlipI[1][0]=upperlip[1][0]=-9.0f;
	upperlipI[1][1]=upperlip[1][1]=-20.0f;
	upperlipI[1][2]=upperlip[1][2]=87.0f;
	upperlipI[2][0]=upperlip[2][0]=10.0f;
	upperlipI[2][1]=upperlip[2][1]=-20.0f;
	upperlipI[2][2]=upperlip[2][2]=87.0f;
	upperlipI[3][0]=upperlip[3][0]=24.0f;
	upperlipI[3][1]=upperlip[3][1]=-30.0f;
	upperlipI[3][2]=upperlip[3][2]=80.0f;

	lowerlipI[0][0]=lowerlip[0][0]=-24.0f;
	lowerlipI[0][1]=lowerlip[0][1]=-30.0f;
	lowerlipI[0][2]=lowerlip[0][2]=80.0f;

	lowerlipI[1][0]=lowerlip[1][0]=-9.0f;
	lowerlipI[1][1]=lowerlip[1][1]=-30.0f;
	lowerlipI[1][2]=lowerlip[1][2]=89.0f;

	lowerlipI[2][0]=lowerlip[2][0]=9.0f;
	lowerlipI[2][1]=lowerlip[2][1]=-30.0f;
	lowerlipI[2][2]=lowerlip[2][2]=89.0f;

	lowerlipI[3][0]=lowerlip[3][0]=24.0f;
	lowerlipI[3][1]=lowerlip[3][1]=-30.0f;
	lowerlipI[3][2]=lowerlip[3][2]=80.0f;

	jaw=0;
}

void model::lookUp(float val){
	glPushMatrix();
	glLoadMatrixf(eyeM);
	glRotatef(val,1,0,0);
	glGetFloatv(GL_MODELVIEW_MATRIX,eyeM);
}

void model::lookRight(float val){
	glPushMatrix();
	glLoadMatrixf(eyeM);
	glRotatef(val,0,1,0);
	glGetFloatv(GL_MODELVIEW_MATRIX,eyeM);
}


void model::openJaw(float val){
	GLfloat temp[16];
	jaw+=val;
	glLoadIdentity();
	glTranslatef(0.0f,-50.0f,0.0f);
	glRotatef(jaw,1.0f,0.0f,0.0f);
	glTranslatef(0.0f,50.0f,0.0f);
	glGetFloatv(GL_MODELVIEW_MATRIX,temp);
	for(int i=0;i<order/3;i++){
		if(jawVerts[i]){
			translated[3*i]=temp[0]*points[3*i]+temp[4]*points[3*i+1]+temp[8]*points[3*i+2]+temp[12];
			translated[3*i+1]=temp[1]*points[3*i]+temp[5]*points[3*i+1]+temp[9]*points[3*i+2]+temp[13];
			translated[3*i+2]=temp[2]*points[3*i]+temp[6]*points[3*i+1]+temp[10]*points[3*i+2]+temp[14];
		}
	}
}

void model::openMouth(float val){
	GLfloat temp[16];
	jaw+=val;
	glLoadIdentity();
	glTranslatef(0.0f,-50.0f,0.0f);
	glRotatef(jaw,1.0f,0.0f,0.0f);
	glTranslatef(0.0f,50.0f,0.0f);
	glGetFloatv(GL_MODELVIEW_MATRIX,temp);
	for(int i=0;i<order/3;i++){
		if(jawVerts[i]){
			translated[3*i]=temp[0]*points[3*i]+temp[4]*points[3*i+1]+temp[8]*points[3*i+2]+temp[12];
			translated[3*i+1]=temp[1]*points[3*i]+temp[5]*points[3*i+1]+temp[9]*points[3*i+2]+temp[13];
			translated[3*i+2]=temp[2]*points[3*i]+temp[6]*points[3*i+1]+temp[10]*points[3*i+2]+temp[14];
		}
	}
	for(int i=1;i<3;i++){
		lowerlip[i][0]=temp[0]*lowerlipI[i][0]+temp[4]*lowerlipI[i][1]+temp[8]*lowerlipI[i][2]+temp[12];
		lowerlip[i][1]=temp[1]*lowerlipI[i][0]+temp[5]*lowerlipI[i][1]+temp[9]*lowerlipI[i][2]+temp[13];
		lowerlip[i][2]=temp[2]*lowerlipI[i][0]+temp[6]*lowerlipI[i][1]+temp[10]*lowerlipI[i][2]+temp[14];
	}
	glLoadIdentity();
	glTranslatef(0.0f,-50.0f,0.0f);
	glRotatef(jaw/2.0f,1.0f,0.0f,0.0f);
	glTranslatef(0.0f,50.0f,0.0f);
	glGetFloatv(GL_MODELVIEW_MATRIX,temp);
	for(int i=0;i<4;i+=3){
		upperlip[i][0]=lowerlip[i][0]=temp[0]*lowerlipI[i][0]+temp[4]*lowerlipI[i][1]+temp[8]*lowerlipI[i][2]+temp[12];
		upperlip[i][1]=lowerlip[i][1]=temp[1]*lowerlipI[i][0]+temp[5]*lowerlipI[i][1]+temp[9]*lowerlipI[i][2]+temp[13];
		upperlip[i][2]=lowerlip[i][2]=temp[2]*lowerlipI[i][0]+temp[6]*lowerlipI[i][1]+temp[10]*lowerlipI[i][2]+temp[14];
	}
}
void model::applyMouthFFD(){
	for(int p=0;p<order/3;p++){
		if(lowerlipVerts[p]){
			float P[]={0,0,0};
			float loc[3];
			loc[0]=(points[3*p]-lowerlip[0][0])/48;
			loc[1]=(points[3*p+1]-lowerlipI[0][1])/2;
			loc[2]=(points[3*p+2]-lowerlipI[0][2])/9;
			float temp=1.0f-loc[0];
			float S[]={temp*temp*temp,
						3*temp*temp*loc[0],
						3*temp*loc[0]*loc[0],
						loc[0]*loc[0]*loc[0]};
			for(int i=0;i<4;i++){
				P[1]+=(lowerlip[i][1]-lowerlipI[i][1])*S[i];
			}
			translated[3*p+1]=P[1]+points[3*p+1];
		}else if(upperlipVerts[p]){
			float P[]={0,0,0};
			float loc[3];
			loc[0]=(points[3*p]-upperlipI[0][0])/48;
			float temp=1.0f-loc[0];
			float S[]={temp*temp*temp,
						3*temp*temp*loc[0],
						3*temp*loc[0]*loc[0],
						loc[0]*loc[0]*loc[0]};
			for(int i=0;i<4;i++){
				P[1]+=(upperlip[i][1]-upperlipI[i][1])*S[i];
			}
			translated[3*p+1]=P[1]+points[3*p+1];
		}
	}
}
void model::applyBrowFFD(){
	for(int p=0;p<order/3;p++){
		if(leftbrowVerts[p]){
			float P[]={0,0,0};
			float loc[3];
			loc[0]=(leftbrowI[0][0]-points[3*p])/30;
			loc[1]=(leftbrowI[0][1]-points[3*p+1])/10;
			loc[2]=(leftbrowI[0][2]-points[3*p+2])/20;
			float temp=1.0f-loc[0];
			float S[]={temp*temp*temp,
						3*temp*temp*loc[0],
						3*temp*loc[0]*loc[0],
						loc[0]*loc[0]*loc[0]};
			for(int i=0;i<4;i++){
				P[0]+=(leftbrow[i][0]-leftbrowI[i][0])*S[i];
				P[1]+=(leftbrow[i][1]-leftbrowI[i][1])*S[i];
				P[2]+=(leftbrow[i][2]-leftbrowI[i][2])*S[i];
			}
			translated[3*p]=P[0]+points[3*p];
			translated[3*p+1]=P[1]+points[3*p+1];
			translated[3*p+2]=P[2]+points[3*p+2];
		}else if(rightbrowVerts[p]){
			float P[]={0,0,0};
			float loc[3];
			loc[0]=(points[3*p]-rightbrow[0][0])/30;
			loc[1]=(points[3*p+1]-rightbrowI[0][1])/10;
			loc[2]=(points[3*p+2]-rightbrowI[0][2])/20;
			float temp=1.0f-loc[0];
			float S[]={temp*temp*temp,
						3*temp*temp*loc[0],
						3*temp*loc[0]*loc[0],
						loc[0]*loc[0]*loc[0]};
			for(int i=0;i<4;i++){
				P[0]+=(rightbrow[i][0]-rightbrowI[i][0])*S[i];
				P[1]+=(rightbrow[i][1]-rightbrowI[i][1])*S[i];
				P[2]+=(rightbrow[i][2]-rightbrowI[i][2])*S[i];
			}
			translated[3*p]=P[0]+points[3*p];
			translated[3*p+1]=P[1]+points[3*p+1];
			translated[3*p+2]=P[2]+points[3*p+2];
		}
	}
}

void model::raiseLeft(float val){
	lowerlip[3][1]=upperlip[3][1]-=val;
}

void model::raiseRight(float val){
	lowerlip[0][1]=upperlip[0][1]-=val;
}

void model::curlLip(float val){
	upperlip[1][1]-=val/2;
	upperlip[2][1]-=val/2;
	lowerlip[1][1]-=val/2;
	lowerlip[2][1]-=val/2;
}
void model::Oface(float val){
	upperlip[0][0]-=val;

	upperlip[3][0]+=val;

	upperlip[1][0]-=val/2;
	upperlip[1][1]-=val/2;
	upperlip[2][0]+=val/2;
	upperlip[2][1]-=val/2;

	lowerlip[1][0]-=val;
	lowerlip[1][1]+=val;
	lowerlip[2][0]+=val;
	lowerlip[2][1]+=val;
}

void model::lowerLeftBrowO(float val){
	leftbrow[0][1]+=val/2;
	leftbrow[1][1]+=val;
	leftbrow[2][1]+=val;
	leftbrow[3][1]+=val/2;
}

void model::lowerRightBrowO(float val){
	rightbrow[0][1]+=val/2;
	rightbrow[1][1]+=val;
	rightbrow[2][1]+=val;
	rightbrow[3][1]+=val/2;
}

void model::lowerRightBrowI(float val){
	rightbrow[1][1]+=val/2;
	rightbrow[2][1]+=val;
	rightbrow[3][1]+=val;
}

void model::lowerLeftBrowI(float val){
	leftbrow[1][1]+=val/2;
	leftbrow[2][1]+=val;
	leftbrow[3][1]+=val;
}

void drawEye(){
	float pupil[]={0.0f,0.0f,0.0f,1.0f};
	float iris[]={0.0f,0.0f,1.0f,1.0f};
	float whites[]={1.0f,1.0f,1.0f,1.0f};
	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, whites);
	gluSphere(gluNewQuadric(),10.0,16,16);
	glTranslatef(0.0f,0.0f,0.6f);
	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, iris);
	gluSphere(gluNewQuadric(),9.5,16,16);
	glTranslatef(0.0f,0.0f,1.51f);
	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, pupil);
	gluSphere(gluNewQuadric(),8.0,16,16);
}

void model::drawModel(bool test){
	float mat[]={0.87f,0.78f,0.69f,1.0f};
	float red[]={1,0,0};
	glLoadMatrixf(matrix);
	glNormalPointer (GL_FLOAT, 0, vertNorms);
	glVertexPointer (3, GL_FLOAT, 0, translated);
	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat);

	//glShadeModel(GL_FLAT);
	string n2="a";
	string n="b";
	for(int i=0;i<P;i++){
		if(test){
			if(!polynames[i].compare(n2)==0&&!polynames[i].compare(n)==0) continue;
		}
		glBegin(GL_POLYGON);
		for(int j=1;j<=lines[i][0];j++){
			glArrayElement(lines[i][j]-1);
		}
		glEnd();
	}

	/*
	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, red);
	glBegin(GL_LINE_STRIP);
	for(int i=0;i<4;i++){
		glVertex3f(lowerlip[i][0],lowerlip[i][1],lowerlip[i][2]);
	}
	glEnd();
	glBegin(GL_LINE_STRIP);
	for(int i=0;i<4;i++){
		glVertex3f(upperlip[i][0],upperlip[i][1],upperlip[i][2]);
	}
	glEnd();
	*/

	glTranslatef(lefteyeX, lefteyeY, lefteyeZ);
	glMultMatrixf(eyeM);
	drawEye();

	glLoadMatrixf(matrix);
	glTranslatef(righteyeX,righteyeY,righteyeZ);
	glMultMatrixf(eyeM);
	drawEye();
}

void model::reset(){
	initMatrices();
	initFFD();
	for(int i=0;i<order/3;i++){
		translated[3*i]=points[3*i];
		translated[3*i+1]=points[3*i+1];
		translated[3*i+2]=points[3*i+2];
	}
}

void model::rotateX(float rot){
	glPushMatrix();
	glLoadMatrixf(matrix);
	glRotatef(rot,1,0,0);
	glGetFloatv(GL_MODELVIEW_MATRIX,matrix);
}

void model::rotateY(float rot){
	glPushMatrix();
	glLoadMatrixf(matrix);
	glRotatef(rot,0,1,0);
	glGetFloatv(GL_MODELVIEW_MATRIX,matrix);
}

void model::rotateZ(float rot){
	glPushMatrix();
	glLoadMatrixf(matrix);
	glRotatef(rot,0,0,1);
	glGetFloatv(GL_MODELVIEW_MATRIX,matrix);
}

void model::scale(float x, float y, float z){
	glPushMatrix();
	glLoadMatrixf(matrix);
	glScalef(size, size, size);
	glGetFloatv(GL_MODELVIEW_MATRIX,matrix);
}

void model::translate(float x, float y, float z){
	matrix[12]+=x;
	matrix[13]+=y;
	matrix[14]+=z;
}