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

// _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);
	}
};

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

//long long unique = 1;
//
//long long get_unique() {
//	
//}

class Editor : Window {
public:
	int frame_i;
	Editor() : Window("AMPS", glutGet(GLUT_SCREEN_WIDTH), glutGet(GLUT_SCREEN_HEIGHT), 0), frame_i(0) {
		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(0, static_timer_animate, window);
	}
private:
	virtual void display() {
//		cerr << "display" << endl;
		glClear(GL_COLOR_BUFFER_BIT);
		glutWireTeapot(0.5);
		glutSwapBuffers();
	}
	void animate() {
//		cerr << "animate" <<endl;
		++frame_i;
		if (frame_i % 10000 == 0)
			cerr << frame_i << endl;
		glRotated(0.5, 4, 5, 6);
		refresh();
		// and continue!
		glutTimerFunc(10, 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();
//		AMPS::Editor *e = static_cast<AMPS::Editor*>(windows[window]);
//		e->display();
//		windows[window]->display();
//		dynamic_cast<Editor*>(windows[window])->animate();
	}
};

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

class Compiler {
};

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

struct Edge {
	Num x, y;
	Num bend;
};

struct Shape {
	string name;
	int n_edges;
	Edge *edges;
	Num radius;
};

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 {
};

}

// _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;
}