#include "ls3d.h"
#include <iostream>

#define USER_EVENT_TIMER 1

using namespace std;

Uint32 timercb(Uint32 interval, void *param) {
    SDL_Event event;
    SDL_UserEvent userevent;

    userevent.type = SDL_USEREVENT;
    userevent.code = USER_EVENT_TIMER;
    userevent.data1 = NULL;
    userevent.data2 = NULL;

    event.type = SDL_USEREVENT;
    event.user = userevent;

    SDL_PushEvent(&event);
    return interval;
}

int main() {
	SDL_Surface *screen;

	ThreeDRenderer *ls3d;
	Camera *cam;
	Mesh *mesh;
	Model *ent, *ent2;
	Vertex *v1, *v2, *v3;

	int ms, temp;
	int frames = 0;

	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0) {
		cout << "Error while initializing SDL: " << SDL_GetError() << endl;
		exit(1);
	}

	atexit(SDL_Quit);

	if ((screen = SDL_SetVideoMode(640, 480, 32, SDL_SWSURFACE | SDL_DOUBLEBUF /*| SDL_FULLSCREEN*/)) == NULL) {
		cout << "Error while setting video mode: " << SDL_GetError() << endl;
		exit(1);
	}

	SDL_WM_SetCaption("LS3D Software Renderer", "");

	ls3d = new ThreeDRenderer();

	cam = ls3d->CreateCamera();

	mesh = new Mesh();

	/*v1 = mesh->AddVertex(10.0, 0.0, 10.0);
	v2 = mesh->AddVertex(-10.0, 0.0, 10.0);
	v3 = mesh->AddVertex(0.0, -0.2, 0.0);

	mesh->AddTriangle(v1, v2, v3, 0xFF0000);

	v3 = mesh->AddVertex(-8.0, 3.0, 10.0);

	mesh->AddTriangle(v1, v2, v3, 0x00FF00);

	v2 = mesh->AddVertex(10.0, 5.0, 10.0);

	mesh->AddTriangle(v1, v2, v3, 0x0000FF);*/

	Vertex *ft, *fb, *nt, *nb, *lt, *lb;

	int color = 0xFF6B00;

	float radius = 5.0;
	float angle = 0.0;
	bool isout = false;
	for (int i = 0; i <= 60; ++i) {
		nt = mesh->AddVertex(cos(angle) * radius, 2.0, sin(angle) * radius);
		nb = mesh->AddVertex(cos(angle) * radius, -2.0, sin(angle) * radius);
		//nt = mesh->AddVertex(cos(angle) * radius, sin(angle) * radius, 2.0);
		//nb = mesh->AddVertex(cos(angle) * radius, sin(angle) * radius, -2.0);
		//nt = mesh->AddVertex(cos(angle) * 5 + (cos(angle) / 2),  sin(angle / 2), sin(angle) * 5 + (cos(angle) / 2));
		//nb = mesh->AddVertex(cos(angle) * 5 - (cos(angle) / 2), -sin(angle / 2), sin(angle) * 5 - (cos(angle) / 2));
		if (i == 0) {
			ft = nt;
			fb = nb;
		} else {
			mesh->AddTriangle(lt, lb, nt, color);
			mesh->AddTriangle(nt, lb, nb, color);
		}
		lt = nt;
		lb = nb;
		if (i % 3 == 0) {
			isout = !isout;
			radius = 5.0 + (isout ? 2.0 : 0.0);
		} else {
			angle += ((M_PI * 2) / 40);
		}
		//color += 0xFF6D00;
		//angle += ((M_PI * 2) / 20);
		//radius += 0.03;
	}
	//mesh->AddTriangle(lt, lb, ft, color);
	//mesh->AddTriangle(ft, fb, lb, color);

	/*for (int i = 0; i < 100; ++i) {
		v1 = mesh->AddVertex((float)(rand() * 100), (float)(if (event.key.keysym.sym == SDLK_SPACE) {rand() * 100), (float)(rand() * 500) + 200);
		v2 = mesh->AddVertex((float)(rand() * 100), (float)(rand() * 100), (float)(rand() * 500) + 200);
		v3 = mesh->AddVertex((float)(rand() * 100), (float)(rand() * 100), (float)(rand() * 500) + 200);
		mesh->AddTriangle(v1, v2, v3, rand() % 0xFFFFFF);
	}*/

#ifdef DEBUG
	//mesh->DebugDump();
#endif

	mesh->UpdateNormals();

	ent = ls3d->CreateModel(mesh);
	ent2 = ls3d->CreateModel(mesh);
	//ent2->color = 0xFFFFFF;
	//ent2->scalex = ent2->scaley = ent2->scalez = 1.1;

	//SDL_UpdateRect(screen, 0, 0, 640, 480);

	angle = 0.0;

	SDL_AddTimer(30, timercb, NULL);

	SDL_Rect wholesurf = {0, 0, screen->w, screen->h};

	bool update = true;

	ent->pos.z = ent2->pos.z = 40.0;
	ent->pos.x = -6.5;
	ent->pos.y = -6.0;
	ent2->pos.x = 6.5;
	ent2->pos.y = -6.0;

	//std::cout << "BLAAHHH" << std::endl;

	ms = SDL_GetTicks();
	while (true) {
	    SDL_Event event;

	    while (SDL_PollEvent(&event)) {
		    switch (event.type) {
		        case SDL_USEREVENT:
		        	if (event.user.code == USER_EVENT_TIMER && update) {
		        		//std::cout << "YAY" << std::endl;
		        		//ent->pos.y = ent->pos.x = sin(angle) * 5.0;
		        		//ent->pos.z = 40.0; //sin(angle) * 20.0 + 150.0;
		        		/*angle += M_PI / 16;
		        		if (angle > M_PI * 2) {
		        			angle -= M_PI * 2;
		        		}*/

		        		/*ent->rotx += M_PI / 64;
		        		if (ent->rotx > M_PI * 2) {
		        			ent->rotx -= M_PI * 2;
		        		}
		        		//ent->rotx = M_PI / 8;
		        		*/
		        		ent->roty += M_PI / 128;
		        		if (ent->roty > M_PI * 2) {
		        			ent->roty -= M_PI * 2;
		        		}
		        		//ent2->roty = M_PI / 2 - M_PI / 16;
		        		ent2->roty = -ent->roty;

                        ent->rotz = -M_PI / 15;
                        ent2->rotz = M_PI / 15;
		        		/*
		        		ent->rotz += M_PI / 128;
		        		if (ent->rotz > M_PI * 2) {
		        			ent->rotz -= M_PI * 2;
		        		}
		        		ent2->rotz = -ent->rotz;
		        		*/
		        		/*ent2->rotx = ent->rotx;
		        		ent2->roty = ent->roty;
		        		ent2->rotz = ent->rotz;
		        		ent2->pos.z = ent->pos.z;*/
		        		//ent->rotz = M_PI / 2;
		        	}
		        	break;
		        case SDL_KEYDOWN:
		        	if (event.key.keysym.sym == SDLK_SPACE) {
		        		update = false;
		        	} else if (event.key.keysym.sym == SDLK_ESCAPE) {
		        		exit(0);
		        	}
		        	break;
		        case SDL_KEYUP:
		        	if (event.key.keysym.sym == SDLK_SPACE) {
		        		update = true;
		        	}
		        	break;
		        case SDL_QUIT:
		            exit(0);
		            break;
		    }
		}

		frames++;

		temp = SDL_GetTicks() - ms;
		if (temp >= 1000) {
			std::cout << "FPS: " << ((frames * 1000) / temp) << std::endl;
			ms = SDL_GetTicks();
			frames = 0;
		}

		//if (SDL_MUSTLOCK(screen)) {
			SDL_LockSurface(screen);
		//}

		SDL_FillRect(screen, &wholesurf, 0x000000);

		ls3d->Render(screen, cam);

		//if (SDL_MUSTLOCK(screen)) {
			SDL_UnlockSurface(screen);
		//}

		SDL_Flip(screen);
	}
}