//////////////////////////////////////////////////////////////
//                                                          //
// Project: SDL/OpenGL template                             //
// Goal   : just open a window with a valid OpenGL context  //
// Author : Achille Peternier, VRLab - EPFL, 2005           //
//                                                          //
//////////////////////////////////////////////////////////////

//////////////
// #INCLUDE //
//////////////

#ifndef UNIX
#include <windows.h>    // Only required under Windows :-D
#endif

#ifndef UNIX
#include <SDL.h>        // This file import the SDL inteface
#else
#include <SDL/SDL.h>    // This file import the SDL inteface
#endif

#include <GL/gl.h>      // This file import the OpenGL interface
#include <GL/glu.h>     // This file offers some OpenGL-related utilities

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

#include <string>
#include <iostream>
#include <fstream>

#include <math.h>

#ifndef UNIX
/////////////
// #PRAGMA //
/////////////
// Visual Studio specific: you can import libraries directly by
// specifing them through a #pragma. On other compilters/platforms add
// the required .lib to the makefile or project proprieties
#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "glu32.lib")
#pragma comment(lib, "sdl.lib")
#pragma comment(lib, "sdlmain.lib")
#endif

#include "vec.h"
#include "color.h"
#include "poly.h"
#include "model.h"
#include "light.h"

using namespace std;

// Constants hardcoded during compilation
#define WINDOW_TITLE       "the cube"
#define WINDOW_X           800   // Window width
#define WINDOW_Y           600   // Window height
#define WINDOW_COLORDEPTH  32    // Color depth (in bits)
#define WINDOW_ZETADEPTH   24    // z-buffer depth (in bits)

#define SURFACE_COUNT      6
#define PI                 3.14159265f

int debugct = 0;

#define DD() do { printf("DD:%d\n", debugct); debugct++;} while(0);

#ifndef UNIX
#define mysleep(x) do {Sleep(x/100);} while (0);
#else
#define mysleep(x) do {usleep(x);} while (0);
#endif
///////////////////////////////////////////////////////////////////////////
// GLOBAL VARS

int MouseX, MouseY, OldMouseX, OldMouseY;
bool MouseButtonRight, MouseButtonLeft;
bool done = false;   // Quit application when true

string getNextToken(string& line) {
	if ( line.length() < 1 ) {
		return "";
	}

	string mp;

	while ( line[0] == ' ' ) {
		line.erase(0, 1);
	}

	int np = line.find(" ", 0);

	if ( (unsigned int)np == string::npos ) {
		np = line.length();
	}

	mp = line.substr(0, np);
	line.erase(0, np);

	return mp;
}

int getNextPoint(string& line) {
	string tch;
	int sp;
	tch = getNextToken(line);
	if ( tch == "" ) {
		return -1;
	}
	if ( (unsigned int)(sp = tch.find("/", 0)) != string::npos ) {
		tch.erase(sp);
	}
	return (int)atoi(tch.c_str());
}

float getNextCoord(string& line) {
	const char* tch;
	tch = getNextToken(line).c_str();
	if ( tch == "" ) {
		return -1;
	}
	return (float)atof(tch);
}

Model* importModel(char* fname) {

	string line;
	ifstream fp;

	std::vector<Vec*> points;
	Model* mm = new Model();

	Poly* tpoly;

	int tp = -1;

	
	fp.open(fname);

	if ( ! fp.is_open()) {
		printf("Error reading file %s\n", fname);
		return mm;
	}

	while ( !fp.eof() ) {
		getline(fp, line);

		if ( line[0] == 'v' ) {
			line.erase(0,1);
			points.push_back(new Vec(getNextCoord(line), getNextCoord(line), getNextCoord(line)));
		}

		if ( line[0] == 'f' ) {
			line.erase(0,1);

			tpoly = new Poly();
			while ( (tp = getNextPoint(line)) > -1 ) {
				tpoly->addPoint(points.at(tp-1));
			}
			mm->addFace(tpoly);
		}
	}

	fp.close();

	return mm;
}


///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// MAIN //

int main( int argc, char **argv ) {
  char a = '|';
  printf("%d", a);

	// Initialize SDL:
	if (SDL_Init(SDL_INIT_VIDEO) == -1) {
		printf("ERROR: unable to init SDL!\n");
		return 1;
	}

	Vec viewer_zmove_pos = Vec(0.0f, 0.0f, 0.1f);
	Vec viewer_zmove_neg = Vec(0.0f, 0.0f, -0.1f);
	Vec viewer_xmove_pos = Vec(0.1f, 0.0f, 0.0f);
	Vec viewer_xmove_neg = Vec(-0.1f, 0.0f, 0.0f);

	Color black  (0,0,0);
	Color blue   (0,0,1);
	Color red    (1,0,0);
	Color violet (1,0,1);
	Color yellow (1,1,0);
	Color white  (1,1,1);
	Color green  (0,1,0);
	Color cyan   (0,1,1);

	Vec* p0  = new Vec(0 ,0 ,0 );
	Vec* p1  = new Vec(10,0 ,0 );
	Vec* p2  = new Vec(10,10,0 );
	Vec* p3  = new Vec(0 ,10,0 );

	Vec* p4  = new Vec(0 ,0 ,10);
	Vec* p5  = new Vec(10,0 ,10);
	Vec* p6  = new Vec(10,10,10);
	Vec* p7  = new Vec(0 ,10,10);

	Vec cen (5,5,5);
	
	Model* cube = new Model();

	/*
	 *
	 *       4---7
	 *       |pp5|
	 *   4---0---3---7---4
	 *   |pp2|pp0|pp3|pp1|
	 *   5---1---2---6---5
	 *       |pp4|
	 *       5---6
	 */

	std::vector<Vec*> pp0;
	std::vector<Vec*> pp1;
	std::vector<Vec*> pp2;
	std::vector<Vec*> pp3;
	std::vector<Vec*> pp4;
	std::vector<Vec*> pp5;
	
	pp0.push_back(p0);
	pp0.push_back(p3);
	pp0.push_back(p2);
	pp0.push_back(p1);

	pp1.push_back(p4);
	pp1.push_back(p5);
	pp1.push_back(p6);
	pp1.push_back(p7);

	pp2.push_back(p4);
	pp2.push_back(p0);
	pp2.push_back(p1);
	pp2.push_back(p5);

	pp3.push_back(p2);
	pp3.push_back(p3);
	pp3.push_back(p7);
	pp3.push_back(p6);

	pp4.push_back(p1);
	pp4.push_back(p2);
	pp4.push_back(p6);
	pp4.push_back(p5);

	pp5.push_back(p3);
	pp5.push_back(p0);
	pp5.push_back(p4);
	pp5.push_back(p7);

	cube->addFace(new Poly(pp0, red));
	cube->addFace(new Poly(pp1, green));
	cube->addFace(new Poly(pp2, cyan));
	cube->addFace(new Poly(pp3, blue));
	cube->addFace(new Poly(pp4, yellow));
	cube->addFace(new Poly(pp5, white));
	
	cube->setCenter(cen);

	
	//char* modelfile = "obj/sample.obj";
	char* modelfile = "obj/untitled.obj";
	//char* modelfile = "obj/teapot.obj";
	Model* myModel = importModel(modelfile);
	printf("imported %s : %d faces\n", modelfile, myModel->numFaces());
	//myModel->setCenter(cen);

	myModel->vardump("");
	
	// Prepare configuration:
	int bitsPerColor = 8;
	if (WINDOW_COLORDEPTH == 16) {
		bitsPerColor = 5;
	}

	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, bitsPerColor);
	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, bitsPerColor);
	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, bitsPerColor);
	SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 0);
	SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 0);
	SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 0);
	SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 0);

	if (WINDOW_COLORDEPTH == 32) {
		SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
	} else {
		SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
	}

	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, WINDOW_ZETADEPTH);
	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

	// Create surface:
	unsigned flags = SDL_OPENGL;
	SDL_WM_SetCaption(WINDOW_TITLE, NULL);

	if (SDL_SetVideoMode(WINDOW_X, WINDOW_Y, WINDOW_COLORDEPTH, flags) == NULL ) {
		printf("ERROR: unsupported video configuration!\n");
		return 1;
	}

	// Ok, SDL up with a valid OpenGL context!
	// Now setup some OpenGL parameter:
	// Clear background with a darkblue color
	glClearColor(0.0f, 0.0f, 0.5f, 1.0f);

	// correct clipping
	glEnable (GL_DEPTH_TEST);

	//enable light
	glEnable(GL_LIGHTING);

	//light info
	Vec l0_dir(0.0f, 0.0f, 0.0f);
	Vec l0_pos(10.0f, -10.0f, 10.0f);
	Color l0_col(1.0f, 0.0f, 0.0f);

	Vec l1_dir(0.0f, 0.0f, 0.0f);
	Vec l1_pos(15.0f, 15.0f, 15.0f);

	//DiffuseLight light0(&l0_pos, &l0_col, GL_LIGHT0);
	Light light0(&l1_pos, &l1_dir, GL_LIGHT1);

	glEnable(GL_COLOR_MATERIAL);
 

  
	///////////////////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////////////////
	// Mainloop:

	float deltay = 0.0f;
	float deltaz = 0.0f;
	float deltacolor = 0.0f;

	Vec viewer = Vec(0.0f, 0.0f, -50.0f);


	while (!done) {
		/////////////////////
		// Do some rendering:
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		// Setup a perspective view:
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluPerspective(45.0f,             // Field of view
				WINDOW_X/WINDOW_Y,  // width/height ratio
				1.0f,               // near clipping plane
				1000.0f);           // far clipping plane

		// Place the viewer 50 units backward:
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		glTranslatef(viewer.x(), viewer.y(), viewer.z());
		viewer.vardump(" ");

		// Draw a rotating triangle:
		glRotatef(deltay, 0.0f, 1.0f, 0.0f); // Rotation around the Y axis
		glRotatef(deltaz, 1.0f, 0.0f, 0.0f);

		cube->draw();
		cube->rotate(Vec(0.0f, 0.01f, 0.01f));


		//myModel->draw();

		//light0.draw();
		//light0.trace();
		//light1.draw();
		//light1.trace();

		////////////////
		// Check events:
		SDL_Event event;

		while (SDL_PollEvent(&event)) {
			// Quit by click on X:
			if (event.type == SDL_QUIT) {
				done = true;
			}
		}

		// Update mouse:
		OldMouseX = MouseX;
		OldMouseY = MouseY;
		unsigned buttons = SDL_GetMouseState(&MouseX, &MouseY);

		if (buttons&SDL_BUTTON(1)) {
			MouseButtonLeft = true;
		} else {
			MouseButtonLeft = false;
		}

		if (buttons&SDL_BUTTON(3)) {// <-- Beware: may be 2 on mouses
			// without the middle button!
			MouseButtonRight = true;
		} else {
			MouseButtonRight = false;
		}

		//if (MouseButtonLeft)
		//      delta += 1.0f;

		// Update keyboard (used like a joypad):
		Uint8 *keystate = SDL_GetKeyState(NULL);
		if (keystate[SDLK_ESCAPE]) {
			done = true;
		}

		// lights
		if (keystate[SDLK_1]) light0.flip();
		//if (keystate[SDLK_2]) light1.flip();

		//background color
		/*		if (keystate[SDLK_1]) {
			glClearColor(0.5f, 0.0f, 0.0f, 1.0f);
		}

		if (keystate[SDLK_2]) {
			glClearColor(0.0f, 0.5f, 0.0f, 1.0f);
		}

		if (keystate[SDLK_3]) {
			glClearColor(0.0f, 0.0f, 0.5f, 1.0f);
			}*/

		//scene rotation
		if (keystate[SDLK_LEFT]) deltay -= 2.0f;		
		if (keystate[SDLK_RIGHT]) deltay += 2.0f;
		if (keystate[SDLK_UP]) deltaz -= 2.0f;
		if (keystate[SDLK_DOWN]) deltaz += 2.0f;
		
		// move viewer
		if (keystate[SDLK_w]) viewer.add(viewer_zmove_neg);
		if (keystate[SDLK_s]) viewer.add(viewer_zmove_pos);
		if (keystate[SDLK_a]) viewer.add(viewer_xmove_pos);
		if (keystate[SDLK_d]) viewer.add(viewer_xmove_neg);

		if (keystate[SDLK_SPACE]) {
			deltacolor += 0.01f;
			if (deltacolor > 1.0f) {
				deltacolor = 0.0f;
			}
		}

		
		////////////////
		// Swap buffers:
		mysleep(2000); // Just don't kill computer resources ;)
		SDL_GL_SwapBuffers();
	}

	// Ok, release everything and byebye:
	SDL_Quit();
	return 0;
}