#include <stdio.h>
#include <OpenGL/gl.h>
#include <GLUT/GLUT.h>
#include <time.h>
#include <stdlib.h>

#define SCREEN_WIDTH 1000
#define SCREEN_HEIGHT 800

float theta = 0;
float phi = 0;
float height = 10.0;
float width = 10.0;
float red[] = { 1.0, 0, 0, 1.0 };
float green[] = { 0.0, 0.9, 0, 1.0 };
float blue[] = { 0, 0, 1, 1 };
float terrain_map[1025][1025];
float height_map[11][11] = {
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ 0, 0, 0, 0, 1, 1, 0, 0, 0, 0 },
	{ 0, 0, 0, 1, 2, 2, 1, 1, 0, 0 },
	{ 0, 0, 1, 2, 3, 4, 2, 1, 0, 0 },
	{ 0, 1, 3, 4, 5, 4, 3, 1, 0, 0 },
	{ 0, 1, 3, 4, 4, 3, 2, 1, 0, 0 },
	{ 0, 1, 2, 3, 3, 2, 1, 1, 0, 0 },
	{ 0, 1, 1, 2, 1, 1, 1, 0, -1, -2 },
	{ 0, 0, 0, 1, 0, 0, -1, -2, -3, -4 },
	{ 0, 0, 0, 0, 0, 0, -1, -3, -4, -9 }
};



void generate_map(float map[1025][1025], size_t zmin, size_t zmax, size_t xmin, size_t xmax, float disp);
int get_rand(int min, int max);

void mydisplay()
{
	int i, j;
	float mat_specular[] = { 0.4f, 0.4f, 0.4f, 1.0f };
	float mat_diffuse[] = { 0.6f, 0.6f, 0.6f, 1.0f };

	glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
	glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
	glMaterialf(GL_FRONT, GL_SHININESS, 100);

	// create a light and set diffuse component of the light
	float lightIntensity[] = { 1.0f, 1.0f, 1.0f, 1.0f };
	float lightPosition[] = { 700.0f, 700.0f, 700.0f, 1.0f };
	glLightfv(GL_LIGHT0, GL_DIFFUSE, lightIntensity);
	glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);

	glMatrixMode(GL_MODELVIEW);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glPushMatrix();
		glRotatef(phi, 0.0, 1, 0.0);
		glRotatef(theta, 1.0, 1, 1.0);
		glPushMatrix();
			glBegin(GL_LINES);
				glMaterialfv(GL_FRONT, GL_AMBIENT, red);
				glVertex3f(0, 0, 1000);
				glVertex3f(0, 0, 0);
				glMaterialfv(GL_FRONT, GL_AMBIENT, green);
				glVertex3f(0, 0, 0);
				glVertex3f(1000, 0, 0);
				glMaterialfv(GL_FRONT, GL_AMBIENT, blue);
				glVertex3f(0, 0, 0);
				glVertex3f(0, 1000, 0);
			glEnd();
			glMaterialfv(GL_FRONT, GL_AMBIENT, green);
			for (j = 0; j < 128; j++)
			{
				glBegin(GL_TRIANGLE_STRIP);
				for (i = 0; i < 128; i++)
				{/*
					glVertex3f(i * width, height * height_map[j][i], j * width);
					glVertex3f(i * width, height * height_map[j + 1][i], (j + 1) * width);
					glVertex3f((i + 1) * width, height * height_map[j][i + 1], j * width);
					glVertex3f((i + 1) * width, height * height_map[j + 1][i + 1], (j + 1) * width);
				  */
					glVertex3f(i * width, height * terrain_map[j][i], j * width);
					glVertex3f(i * width, height * terrain_map[j + 1][i], (j + 1) * width);
					glVertex3f((i + 1) * width, height * terrain_map[j][i + 1], j * width);
					glVertex3f((i + 1) * width, height * terrain_map[j + 1][i + 1], (j + 1) * width);
				}
				glEnd();
			}
		glPopMatrix();
	glPopMatrix();
	glFlush();
}

void mykeyboard(unsigned char key, int x, int y)
{
	if ('a' == key)
		theta+=5;
	glutPostRedisplay();
}

void myidlefunc()
{
	phi += 0.0015;
	theta += 0.00015;
	glutPostRedisplay();
}

void print_map(float map[1025][1025], size_t z, size_t x)
{
	size_t i, j;
	for (i = 0; i < z; i ++)
	{
		for (j = 0; j < x; j++)
		{
			printf("%f\t", map[i][j]);
		}
		printf("\n");
	}
}

void init_map(float map[1025][1025])
{
	size_t i, j;
	size_t size = 1025;

	for (i = 0; i < size; i++)
	{
		for (j = 0; j < 1025; j++)
		{
			map[i][j] = 0;
		}
	}

	map[0][0] = get_rand(-50, 5);
	map[0][size - 1] = get_rand(-50, 5);
	map[size - 1][0] = get_rand(-50, 5);
	map[size - 1][size - 1] = get_rand(-50, 5);

	generate_map(map, 0, size, 0, size, 0.0);
}

void generate_map(float map[1025][1025], size_t zmin, size_t zmax,
				  size_t xmin, size_t xmax, float disp)
{
	int mid_x;
	int mid_z;
	float A, B, C, D, E;

	mid_x = (xmin + xmax) / 2;
	mid_z = (zmin + zmax) / 2;

	A = map[zmin][xmin];
	B = map[zmax][xmin];
	C = map[zmin][xmax];
	D = map[zmax][xmax];

	map[mid_z][mid_x] = E = ((A + B + C + D) / 4.0) + get_rand(-1, 1);

	if (!map[zmin][mid_x])
		map[zmin][mid_x] = (A + C + E) / 3 + get_rand(-1, 1);

	if (!map[mid_z][xmin])
		map[mid_z][xmin] = (A + B + E) / 3 + get_rand(-1, 1);

	if (!map[zmax][mid_x])
		map[zmax][mid_x] = (B + D + E) / 3 + get_rand(-1, 1);

	if (!map[mid_z][xmax])
		map[mid_z][xmax] = (C + D + E) / 3 + get_rand(-1, 1);

	disp /= 2.0;
	if (mid_z - zmin > 1)
	{
		generate_map(map, zmin, mid_z, xmin, mid_x, disp); // Top Left
		generate_map(map, mid_z, zmax, xmin, mid_x, disp); // Bottom Left
		generate_map(map, zmin, mid_z, mid_x, xmax, disp); // Top Right
		generate_map(map, mid_z, zmax, mid_x, xmax, disp); // Bottom Right
	}
}

int main(int argc, char** argv)
{
	srand(time(0));
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
	glutInitWindowSize(SCREEN_WIDTH, SCREEN_HEIGHT);
	glutInitWindowPosition(100, 100);
	glutCreateWindow("simple");
	glutDisplayFunc(mydisplay);
	glutKeyboardFunc(mykeyboard);
	glutIdleFunc(myidlefunc);
	glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_NORMALIZE);
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
	glEnable(GL_CULL_FACE);
	glClearColor(0, 0, 0, 1.0f);
	glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(80, (float)SCREEN_WIDTH/SCREEN_HEIGHT, 0.1, 10000);
	glMatrixMode(GL_MODELVIEW);
	gluLookAt(1000.0, 300.0, 1000.0,
			  100.0, 0.0, 100.0,
			  0.0, 1.0, 0.0);
	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	init_map(terrain_map);
	glutMainLoop();
}

int get_rand(int min, int max)
{
	int n;

	if (min < 0)
	{
		n = rand() % (-min + max);
		if (n > max)
			n = (n - max) * -1;
	}
	else
	{
		n = rand() % (min + max);
		if (n > max)
			n = (n - max);
	}

	return n;
}