#include <iostream>
#include <fstream>
#define GL_GLEXT_PROTOTYPES
#ifndef __APPLE__
#include <GL/gl.h>
#include <GL/glu.h>
#else
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#endif
#include <math.h>
#include <vector>
#include <list>
#include <queue>
#include <SDL/SDL.h>
#include <FTGL/ftgl.h>
#include "texturesdl.h"
#include "shader.h"
#include "vector.h"
#include "bullet.h"
#include "bulletpattern.h"

class BulletAdder {
	public:
		unsigned int time;
		Bullet bullet;

		BulletAdder(unsigned int time, Bullet bullet) { this->time = time; this->bullet = bullet; }

		bool operator<(const BulletAdder& ba) {
			return time < ba.time;
		};
};

class BulletAdderComparison {
	bool reverse;

	public:
		BulletAdderComparison(const bool& revparam = false) { reverse = revparam; };
		bool operator()(const BulletAdder& left, const BulletAdder& right) {
			return (reverse ? left.time < right.time : left.time > right.time);
		};
};

std::list<Bullet> bullets;
std::priority_queue<BulletAdder, std::vector<BulletAdder>, BulletAdderComparison> bullets_queue;

class BulletPattern1 : public BulletPattern {
	unsigned int base;
	public:
		BulletPattern1(bool reverse, unsigned int base) {
			num_bullets = 0;
			bullets = new float[128];
			this->base = base;

				int j = 0;
				for(float i = 0; i < M_PI; i += 0.1, j++) {
					bullets[j*4] = 50.0 + sinf(!reverse ? M_PI_2 + i : M_PI - i + M_PI_2) * 9;
					bullets[j*4 + 1] = 80 + cosf(M_PI_2 + i) * 10;
					bullets[j*4 + 2] = sinf(!reverse ? M_PI_2 + i : M_PI - i + M_PI_2) / 150.0;
					bullets[j*4 + 3] = -0.01;
				}
		};
		void update(unsigned int time, unsigned int step) {
			if(num_bullets < 32 && base + num_bullets * 10 < time) {
				num_bullets += time / 10 - num_bullets - base / 10;
			}
			for(int i = 0; i < num_bullets; i++) {
				bullets[i*4] += bullets[i*4 + 2] * step;
				bullets[i*4 + 1] += bullets[i*4 + 3] * step;
			}
		}
};

bool fullscreen = false;
void toggle_fullscreen() {
	fullscreen = !fullscreen;
	SDL_SetVideoMode(640, 480, 0, SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE | SDL_HWSURFACE | (fullscreen ? SDL_FULLSCREEN : 0));
}

int main(int, char**) {
	if(SDL_Init(SDL_INIT_VIDEO) < 0) {
		fprintf(stderr, "Failed to initialize SDL: %s\n", SDL_GetError());
		return 1;
	}

	SDL_Surface *surface = SDL_SetVideoMode(640, 480, 0, SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE | SDL_HWSURFACE);
	if(surface == NULL) {
		fprintf(stderr, "Failed to set video mode: %s\n", SDL_GetError());
		return 1;
	}

	SDL_Event event;
	bool running = true;
	bool paused = false;

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

	glEnable(GL_TEXTURE_2D);

	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_BLEND);

	glEnable(GL_POINT_SPRITE);
	glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);

	glClearColor(0, 0, 0, 0);
	glClearDepth(1);

	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);

	glShadeModel(GL_SMOOTH);

	std::vector<BulletPattern*> patterns;
	
	patterns.push_back(new BulletPattern());
	for(int i = 0; i < 8; i++) {
		patterns.push_back(new BulletPattern1(i % 2 == 1, i * 400));
	}

	TextureSDL texture1("foo.png");
	TextureSDL texture2("foo4.png");

	GLFragmentShader shader1("bullet_fragment.glsl");
	GLVertexShader shader2("bullet_vertex.glsl");
	GLShaderProgram program;
	program.attach(shader1);
	program.attach(shader2);
	program.link();

	FTPixmapFont font("VeraMono.ttf");
	font.FaceSize(12);

	float f = 0.0;
	float fps = 0.0;
	unsigned int lasttick = SDL_GetTicks();
	unsigned int elapsed = 0;
	unsigned int lastframes = 0,
				 frames = 0;
	while(running) {
		while(SDL_PollEvent(&event)) {
			switch(event.type) {
				case SDL_QUIT:
					running = false;
					break;
				case SDL_KEYDOWN:
					switch(event.key.keysym.sym) {
						case SDLK_ESCAPE:
							running = false;
							break;
						case SDLK_SPACE:
							paused = !paused;
							lasttick = SDL_GetTicks();
							break;
						case 'f':
							toggle_fullscreen();
							break;
						default:
							break;
					}
					break;
			}
		}

		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluPerspective(45, 640. / 480., 1, 100);

		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();

		unsigned int tick = SDL_GetTicks();
		unsigned int step = tick - lasttick;
		lasttick = tick;

		if(!paused) {
			f += 0.0005 * step;
			elapsed += step;
			while(bullets_queue.size() && bullets_queue.top().time <= elapsed) {
				BulletAdder ba = bullets_queue.top();
				Bullet& bullet = ba.bullet;
				bullets_queue.pop();
				bullets.push_back(bullet);
			}
			for(std::vector<BulletPattern*>::iterator it = patterns.begin(); it < patterns.end(); it++) {
				(*it)->update(elapsed, step);
			}
		}
		
		gluLookAt(
			5 * sinf(f), 1, 5 * cosf(f),
			0, 0, 0,
			5 * sinf(f), 2, 5 * cosf(f));

		glBegin(GL_LINES);
		for(int i = -10; i < 11; i++) {
			if(i % 5 == 0)
				glColor3f(1, 1, 1);
			else
				glColor3f(.5, .5, .5);
			glVertex3f(i, 0, -10);
			glVertex3f(i, 0, 10);
			glVertex3f(-10, 0, i);
			glVertex3f(10, 0, i);
		}
		glEnd();

		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		glOrtho(0, 100, 0, 100, 0, 10);

		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();

		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
		program.use();
		std::list<Bullet>::iterator it;
		glPointSize(16.0);
		glEnable(GL_TEXTURE_2D);
		glBindTexture(GL_TEXTURE_2D, texture2.tex());
		
		glColor4f(1, 0, 0, 1);
		
		for(std::vector<BulletPattern*>::iterator it = patterns.begin(); it < patterns.end(); it++) {
			(*it)->draw();
		}
		
		glColor4f(0, 1, 0, 1);
		
		glBegin(GL_POINTS);
		for(it = bullets.begin(); it != bullets.end();) {
			Bullet& b = (*it);

			if(!paused) {
				b.pos.x += b.direction.x * step;
				b.pos.y += b.direction.y * step;
				b.pos.z += b.direction.z * step;
			}
			
			glVertex4f(b.pos.x, b.pos.y, b.direction.x, b.direction.y);
			
			//glColor3f(b.color.r, b.color.g, b.color.b);
			/*glTexCoord2f(0, 0);
			glVertex3f(b.pos.x-1, b.pos.y-1, b.pos.z);
			glTexCoord2f(1, 0);
			glVertex3f(b.pos.x+1, b.pos.y-1, b.pos.z);
			glTexCoord2f(1, 1);
			glVertex3f(b.pos.x+1, b.pos.y+1, b.pos.z);
			glTexCoord2f(0, 1);
			glVertex3f(b.pos.x-1, b.pos.y+1, b.pos.z);*/

			if(b.pos.x < -b.radius || b.pos.x > 100+b.radius || b.pos.y < -b.radius || b.pos.y > 100+b.radius) {
				it = bullets.erase(it);
			} else {
				it++;
			}
		}
		glEnd();
		//glDisable(GL_POINT_SPRITE);
		glDisable(GL_TEXTURE_2D);

		glUseProgram(0);

		glColor4f(1, 1, 1, 1);

		char s[0xff];

		snprintf(s, 0xff, "Bullets: %d", (int)bullets.size());
		glRasterPos2f(1, 1);
		font.Render(s);

		snprintf(s, 0xff, "Queue: %d", (int)bullets_queue.size());
		glRasterPos2f(1, 1 + font.LineHeight() * (100.0 / 480.0));
		font.Render(s);

		if(tick - lastframes >= 1000) {
			fps = (float)frames * ((float)(tick - lastframes) / 1000.0f);
			frames = 1;
			lastframes = tick;
		} else {
			frames++;
		}
		snprintf(s, 0xff, "FPS: %.2f", fps);
		glRasterPos2f(1, 1 + 2 * font.LineHeight() * (100.0 / 480.0));
		font.Render(s);


		SDL_GL_SwapBuffers();

		SDL_Delay(10);
	}

	SDL_Quit();
}