#include <GL/glut.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>
#include <string>
#include "shape.h"


using namespace std;

Triangle theTriangle;
Triangle theStandardTriangle;
float forward[16];
 float backward[16];

inline float min(float f1, float f2) {return f1<f2 ? f1: f2;}

// function prototypes

void display(void);
void reshape(int width, int height);
void keyboard(unsigned char key, int x, int y);
void motion(int x, int y);
void init(void);




//test stuff
Triangle createRandomTriangle();





// fudge factor
const float epsilon=.0001;

// viewpoint
double theta=0.5, phi=0, d=150;

// window
int width = 400;
int height = 400;





int 
main(int argc, char **argv)
{

  // set up window
  glutInitWindowSize(400, 400);
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutCreateWindow("Triangle Standardization");

  // register callback functions
  glutDisplayFunc(display);
  glutReshapeFunc(reshape); 
  glutKeyboardFunc(keyboard);
  glutMotionFunc(motion);

  
  


  // initalize opengl parameters
  init();

  // create random triangle
  theTriangle = createRandomTriangle();
  theStandardTriangle = theTriangle.standardize(forward,backward);

  // loop until something happens
  glutMainLoop();
  return 0;           
}

void init()
{

  // initialize viewing system
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(45.0, 1.0, 1.0, 1000.0);
  glMatrixMode(GL_MODELVIEW);

  // shading model
  glEnable(GL_SMOOTH);
 

  // initialize background color to black
  glClearColor(0.0,0.0,0.0,0.0);

  // enable depth buffering
  glEnable(GL_DEPTH_TEST);




	glPolygonMode(GL_FRONT, GL_FILL);
	glPolygonMode(GL_BACK, GL_LINE);
}



void reshape(int newWidth, int newHeight)
{
	width = newWidth;
	height = newHeight;
	// preserve aspect ratio
	if (width < height)
		glViewport(0,0,width,width);
	else
		glViewport(0,0,height,height);
}

void display()
{

	// compute eye position
	glLoadIdentity();
	Tuple eye(0,0,0);
	eye[0] = (float) -d * cos(theta) * sin(phi);
	eye[1] = (float) 2*d * sin(theta);
	eye[2] = (float) d * cos(theta) * cos(phi);

	// compute up vector
	// the is the vector orthogonal to eye that lies in the same
	// plane as eye and (0,1,0) and has a positive dot product with
	// (0,1,0)

	Tuple up = Tuple(0,1,0)-eye/eye.length();
	up.normalize();

	gluLookAt(eye[0],eye[1],eye[2], 0,0,0,up[0], up[1], up[2]);
	glTranslatef(-50,0,-50);


	// clear buffers
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// draw axes
	glColor3f(1.0f, 1.0f, 1.0f);
	glBegin(GL_LINES);
		glVertex3f(0.0f, 0.0f, 0.0f);
		glVertex3f(100.0f, 0.0f, 0.0f);
	glEnd();
	glBegin(GL_LINES);
		glVertex3f(0.0f, 0.0f, 0.0f);
		glVertex3f(0.0f, 100.0f, 0.0f);
	glEnd();
	glBegin(GL_LINES);
		glVertex3f(0.0f, 0.0f, 0.0f);
		glVertex3f(0.0f, 0.0f, 100.0f);
	glEnd();

	// draw the triangles
	theTriangle.drawRainbow();
	theStandardTriangle.draw();
	
	// draw to screen
	glutSwapBuffers();
}

void keyboard(unsigned char key, int mouseX, int mouseY)
{

	static float r=0;

	Tuple c,v;

	switch (key) {

		case 'h':
			cout << "h      help" << endl;
			cout << "z/Z    zoom in/out" << endl;
			break;

		case '-':
			if (d>1)
				d--;
			break;
		case '+':
			d++;
			break;

		
		case 'n':
			theTriangle=createRandomTriangle();
			  theStandardTriangle = theTriangle.standardize(forward,backward);
			break;


		default: break;
	}
	glutPostRedisplay();

}


void motion(int x, int y)
{

	static int currX=-1;
	static int currY=-1;

	if (currX>0  && abs(x-currX) < width/6 && abs(y-currY) < height/6) {
		phi += (double) (x-currX)/ (double) width * 3.14159;
		theta += (double) (y-currY)/ (double) height * 3.14159;
	// limit theta to -4pi/9 and 4pi/9
	if (theta < -4*3.14159/9.0)
		theta = -4*3.14159/9.0;
	if (theta > 4*3.14159/9.0)
		theta = 4*3.14159/9.0;
	}
	currX = x;
	currY = y;
	glutPostRedisplay();
}

Triangle createRandomTriangle() 
{

	// create three random vertices in the 10x10x10 cube centered
	// at the origin
	float vals[3];
	Tuple v[3];
	for (int i=0;i<3;i++) {
		for (int j=0;j<3;j++) 
			vals[j] = (((float) rand()/ (float) RAND_MAX) - 0.5f)*100.0f;
		v[i] = Tuple(vals[0],vals[1],vals[2]);

	}
	return Triangle(v[0], v[1], v[2]);

}