// _prelude_
// _generic_
// _glut_
// _window_
// _editor_
// _compiler_
// _shapes_
// _graphs_
// _startup_

//#include "done.cc"

// _prelude_ ---------------------------------------------------------

#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <GL/glut.h>
#include <cmath>

using namespace std;

namespace AMPS {

typedef double Num;

// _generic_ ---------------------------------------------------------

// base object class - not needed?
class Object {
public:
	virtual ~Object() = 0;
};
inline Object::~Object() {}

// _glut_ ------------------------------------------------------------

class Window;
vector<Window *> windows;

// _window_ ----------------------------------------------------------

class Window : Object {
protected:
	int window;
	int width;
	int height;
private:
// This static member 'windows' does not work for some obscure reason.
//	static unordered_map<int,Window *> windows;
	static void static_display() {
		int window = glutGetWindow();
		windows[window]->display();
	}
//	static void static_timer(int window) {
//		windows[window]->timer();
//	}
public:
	Window(const char *title = "app", int width_ = 0, int height_ = 0, bool fullscreen = 0) : width(width_), height(height_) {
		if (width && height) {
			glutInitWindowSize(width, height);
		}
		window = glutCreateWindow(title);
//		cerr << "window: " << window << endl;
		// TODO use growvec?
		if (window >= (int)windows.size())
			windows.resize(window+1);
		windows[window] = this;
		if (fullscreen)
			glutFullScreen();
		glutDisplayFunc(&static_display);
		width = glutGet(GLUT_WINDOW_WIDTH);
		height = glutGet(GLUT_WINDOW_HEIGHT);
	}
	virtual ~Window() {
		glutDestroyWindow(window);
	}
	virtual void display() {
		glClear(GL_COLOR_BUFFER_BIT);
		glutSwapBuffers();
	}
	void refresh() {
//		cerr << "refresh" << window << endl;
		glutPostWindowRedisplay(window);
	}
};

// _shapes_ ----------------------------------------------------------

// max number of pixels error
Num angle_per_radian = 180 / M_PI;
Num arc_max_error = 0.25;
Num a_pixel = 1;
void draw_arc(Num x0, Num y0, Num x1, Num y1, Num angle) {
	angle /= angle_per_radian;

	// TODO simplify, use GL rotate / scale / translate
	Num dx, dy, d, hf, ox, oy, r, da, x, y, s, c, x_, y_, altx, alty, alt;
	Num bend = 1;

	angle = -angle;

	dx = (x1 - x0)/2;
	dy = (y1 - y0)/2;
	d = hypot(dx, dy);

	// calc origin
	hf = 1 / tan(angle / 2);
	ox = x0 + dx + dy*hf * bend;
	oy = y0 + dy - dx*hf * bend;

	// radius
	r = d / sin(fabs(angle)/2);

	// length
//	l = pi2*r * angle / 360

// delta angle
// r * (1 - cos(da/2)) == arc_max_error
//	da = 0.2;
//	da = 1 / angle_per_radian;
	da = acos(1 - arc_max_error * a_pixel / r) * 2;
//	warn("da = %f   old_da(3) = %f  old_da(16) = %f", da, angle / l * 3 * a_pixel, angle / l * 16 * a_pixel)

//	da = angle / l * calc_arc_d * a_pixel

	altx = dy * hf;
	alty = -dx * hf;
	alt = hypot(altx, alty);
	altx /= alt;
	alty /= alt;

//	glVertex2d(x0, y0);

	int steps = fabs(angle) / da;
	for(int i=0; i<steps; ++i) {
		Num a = angle * i / steps - angle / 2;
		s = sin(a);
		c = cos(a) * bend;
		x_ = s * r;
		y_ = c * r;
		x = dy * hf;
		x = ox - x_ * alty - y_ * altx;
		y = oy + x_ * altx - y_ * alty;
		glVertex2d(x, y);
	}

}

class Edge {
public:
	Num x, y;
	Num bend;
	void draw(Num lx, Num ly) {
		if (!bend) {
			glVertex2d(x, y);
		} else {
			// instead of drawing this each time, we can store it in an array, then just call
			// glDrawArrays (or glBegin .. glEnd).  No need for math each time.
			draw_arc(lx, ly, x, y, bend);
		}
	}
};

class Shape {
public:
	string name;
	int n_edges;
	Edge *edges;
	Num radius;
	void draw() {
		// TODO test on screen || return
		//   - see ./shapes
		//   - use gluProject
		//   - need to get matrices, viewport with glGet first.  Keep them 'globals'...
		//   - move 'globals' into a Display object.
		// TODO different colours
		glColor3d(0.5, 0.8, 1);
		glBegin(GL_POLYGON);
		vertices();
		glEnd();
		glColor3d(0, 0, 0.5);
		glBegin(GL_LINE_LOOP);
		vertices();
		glEnd();
	}
	void vertices() {
		Num lx = edges[0].x;
		Num ly = edges[0].y;
		for(int i=1; i<n_edges; ++i) {
			edges[i].draw(lx, ly);
			lx = edges[i].x;
			ly = edges[i].y;
		}
		edges[0].draw(lx, ly);
	}
};

Edge square_edges[] = { {-1,-1,0}, {1,-1,0}, {1,1,0}, {-1,1,0} };
Shape square = { "square", 4, square_edges, M_SQRT2 };

Edge circ_edges[] = { {1,0,180}, {-1,0,180} };
Shape circ = { "circle", 2, circ_edges, 1 };

Edge rect4_edges[] = { {-1,-4,0}, {1,-4,0}, {1,4,0}, {-1,4,0} };
Shape rect4 = { "rect4", 4, rect4_edges, 4.13 };

Edge eye4_edges[] = { {0,-4,60}, {0,4,60} };
Shape eye4 = { "eye4", 2, eye4_edges, 4 };

Edge diamond_edges[] = { {0,-1,0}, {1,0,0}, {0,1,0}, {-1,0,0} };
Shape diamond = { "diamond", 4, diamond_edges, 1 };

// _graphs_ ----------------------------------------------------------

class Graph {
};
class Proc {
};
class Node {
};
class Port {
};
class Arc {
};

// _editor_ ----------------------------------------------------------

class Editor : Window {
public:
	int frame_i;
	Num a;
	Num zoom;
	Editor() : Window("AMPS", glutGet(GLUT_SCREEN_WIDTH), glutGet(GLUT_SCREEN_HEIGHT), 0), frame_i(0), a(5) {
//		gluPerspective(30, (double)width / height, 0.1, 10);
//		glTranslated(0, 0, -2);
		gluOrtho2D(-width/2, width/2, -height/2, height/2);
		// TODO if need other timers, a problem!  use a map?
		glutTimerFunc(1, static_timer_animate, window);
	}
private:
	virtual void display() {
		glPushMatrix();
		glRotated(a, 0, 0, -1);
		zoom = a/360 * 30;
		a_pixel = 1/zoom;  // need to do this when set zoom, for draw_arc
		glScaled(zoom, zoom, zoom);
//		cerr << "display" << endl;
		glClear(GL_COLOR_BUFFER_BIT);
		srandom(1);
		for(int i=0; i<100; ++i) {
			Num r1 = (random()*1.0 / RAND_MAX);
			Num r2 = (random()*1.0 / RAND_MAX);
			Num r3 = (random()*1.0 / RAND_MAX);
			glPushMatrix();
			glTranslated(-50+r1*100, -50+r2*100, 0);
			glRotated(r3 * 360 * 2, 0, 0, -1);
			rect4.draw();
			eye4.draw();
			square.draw();
			circ.draw();
			glPopMatrix();
		}
//		glutWireTeapot(200);
		glPopMatrix();
		glutSwapBuffers();
	}
	void animate() {
//		cerr << "animate" <<endl;
		++frame_i;
		a += 1;
		if (frame_i % 100 == 0)
			cerr << frame_i << endl;
//		glRotated(0.5, 4, 5, 6);
		refresh();
		// and continue!
		glutTimerFunc(1, static_timer_animate, window);
	}
	static void static_timer_animate(int window) {
//		cerr << "in static_timer_animate: window = " << window << endl;
		Window *w = windows[window];
		((AMPS::Editor*)w)->animate();
	}
};

// _compiler_ --------------------------------------------------------

class Compiler {
};

}

// _startup_ ---------------------------------------------------------

void glut_init(int argc, char *argv[]) {
	glutInit(&argc,argv);
	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
}

int main(int argc, char *argv[]) {
	glut_init(argc, argv);
	AMPS::Editor e;
	glutMainLoop();
	return 0;
}