#include <stdio.h>
#include <GL/glut.h>
#include <math.h>

typedef double Num;

Num zoom;

int width;
int height;
const char *title;

Num a;

int doit = 1;
int try_to_die = 0;

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

	da = acos(1 - arc_max_error * a_pixel / r) * 2;

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

	if (try_to_die) {
		printf("glVertex2d(%f, %f);\n", x0, y0);
		if (doit)
			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;
		printf("glVertex2d(%f, %f);\n", x, y);
		if (doit)
			glVertex2d(x, y);
	}
}

class Edge {
public:
	Num x, y;
	Num bend;
	void draw(Num lx, Num ly) {
		if (!bend) {
			printf("glVertex2d(%f, %f);\n", x, y);
			if (doit)
				glVertex2d(x, y);
		} else {
			draw_arc(lx, ly, x, y, bend);
//			glVertex2d(x, y); //
		}
	}
};

class Shape {
public:
	const char *name;
	int n_edges;
	Edge *edges;
	Num radius;
	void draw() {
		printf("glColor3d(0.5, 0.8, 1);\n");
		printf("glBegin(GL_POLYGON);\n");
		if (doit) {
			glColor3d(0.5, 0.8, 1);
			glBegin(GL_POLYGON);
		}
//		printf("poly\n");
		vertices();
		printf("glEnd();\n\n");
		if (doit)
			glEnd();
		printf("glFinish();\n\n");
		if (doit)
			glFinish();
		printf("glColor3d(0, 0, 0.5);\n");
		printf("glBegin(GL_LINE_LOOP);\n");
		if (doit) {
			glColor3d(0, 0, 0.5);
			glBegin(GL_LINE_LOOP);
		}
//		printf("loop\n");
		vertices();
		printf("glEnd();\n\n");
		if (doit)
			glEnd();
		printf("glFinish();\n\n");
		if (doit)
			glFinish();
	}
	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 };

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

void display() {
	printf("glPushMatrix();\n");
	if (doit)
		glPushMatrix();
	printf("glRotated(%f, 0, 0, -1);\n", a);
	if (doit)
		glRotated(a, 0, 0, -1);
	zoom = a/360 * 30;
	a_pixel = 1/zoom;  // need to do this when set zoom, for draw_arc
	printf("glScaled(%f, %f, %f);\n", zoom, zoom, zoom);
	if (doit)
		glScaled(zoom, zoom, zoom);
	printf("glClear(GL_COLOR_BUFFER_BIT);\n");
	if (doit)
		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);
		printf("glPushMatrix();\n");
		if (doit)
			glPushMatrix();
		printf("glTranslated(%f, %f, 0);\n", -50+r1*100, -50+r2*100);
		if (doit)
			glTranslated(-50+r1*100, -50+r2*100, 0);
		printf("glRotated(%f, 0, 0, -1);\n", r3 * 360 * 2);
		if (doit)
			glRotated(r3 * 360 * 2, 0, 0, -1);
		rect4.draw();
		eye4.draw();
		square.draw();
		circ.draw();
		printf("glPopMatrix();\n");
		if (doit)
			glPopMatrix();
	}
	printf("glPopMatrix();\n");
	if (doit)
		glPopMatrix();
	printf("glFinish();\n");
	printf("glutSwapBuffers();\n");
	printf("glFinish();\n");
	if (doit) {
		glFinish();
		glutSwapBuffers();
		glFinish();
	}
}

int main(int argc, char *argv[]) {

	printf(
"#include <stdio.h>\n"
"#include <GL/glut.h>\n"
"#include <math.h>\n"
"typedef double Num;\n"
"Num zoom;\n"
"int width;\n"
"int height;\n"
"const char *title;\n"
"\n"
"int main(int argc, char *argv[]) {\n"
"	glutInit(&argc,argv);\n"
"	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);\n"
"	\n"
"	title = \"AMPS\";\n"
"	\n"
"	glutCreateWindow(title);\n"
"	width = glutGet(GLUT_WINDOW_WIDTH);\n"
"	height = glutGet(GLUT_WINDOW_HEIGHT);\n"
"	\n"
"	gluOrtho2D(-width/2, width/2, -height/2, height/2);\n"
"\n"
);

	if (doit) {
		glutInit(&argc,argv);
		glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
	}

	title = "AMPS";
	if (argc >= 2)
		a = atof(argv[1]);
	a = random()*1.0 / RAND_MAX * 20;
	fprintf(stderr, "%f\n", a);

	if (doit) {
		glutCreateWindow(title);
		width = glutGet(GLUT_WINDOW_WIDTH);
		height = glutGet(GLUT_WINDOW_HEIGHT);
	}

	if (doit)
		gluOrtho2D(-width/2, width/2, -height/2, height/2);

	display();

printf(
"	glutMainLoop();\n"
"	return 0;\n"
"}\n"
);
	if (doit)
		glutMainLoop();
	return 0;
}