#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <glew.h>
#include <vector>
#include <cmath>
#include <ctime>
#include "SOIL.h"
#include <fstream>
#include <glfw3.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <iostream>
#include <vector>
#include <string>

const double M_PI = 3.14;

bool modA = true, modT = false;


GLint red = 0;

GLint green = 255;
GLint blue = 255;

GLint MOVE_X = 0;
GLint MOVE_Y = 0;
GLint MOVE_Z = 0;

GLint ROTATE_X = 0;
GLint ROTATE_Y = 0;
GLint ROTATE_Z = 0;

GLboolean global_ambient = false;
GLboolean two_side = true;
GLboolean local_viewer = true;

GLboolean IS_FILL = false;

GLfloat Amount = 10;

GLfloat SIZE = 1.0f;

GLint floors = 7;

const GLfloat kVerts[] = {
	1,   0,   0,   0,
	0,   1,   0,   0,
	0,   0,   1,   0,
	0,   0,   0,   1
};

GLfloat material_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
GLuint textureID;
GLfloat light0_diffuse[] = { 1,1,0 };
GLfloat light0_position[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat light0_ambient[] = { 1, 1, 1 };
GLfloat light0_spot_direction[] = { -1.0, -1.0, -1.0 };

void key(GLFWwindow * window, int key, int scancode, int action, int mods)
{
	if (action == GLFW_PRESS || action == GLFW_REPEAT) {
		switch (key) {
		case GLFW_KEY_ESCAPE:
			glfwSetWindowShouldClose(window, GLFW_TRUE);
			break;
		case GLFW_KEY_UP:
			MOVE_Y += 10;
			break;
		case GLFW_KEY_DOWN:
			MOVE_Y -= 10;
			break;
		case GLFW_KEY_LEFT:
			MOVE_X -= 10;
			break;
		case GLFW_KEY_RIGHT:
			MOVE_X += 10;
			break;
		case GLFW_KEY_3:
			MOVE_Z += 100;
			break;
		case GLFW_KEY_4:
			MOVE_Z -= 100;
			break;
		case GLFW_KEY_W:
			ROTATE_X += 2;
			break;
		case GLFW_KEY_S:
			ROTATE_X -= 2;
			break;
		case GLFW_KEY_A:
			ROTATE_Y += 2;
			break;
		case GLFW_KEY_D:
			ROTATE_Y -= 2;
			break;
		case GLFW_KEY_5:
			ROTATE_Z += 2;
			break;
		case GLFW_KEY_6:
			ROTATE_Z -= 2;
			break;
		case GLFW_KEY_F:
			IS_FILL = !IS_FILL;
			break;
		case GLFW_KEY_1:
			SIZE += 0.1f;
			break;
		case GLFW_KEY_2:
			SIZE -= 0.1f;
			break;
		case GLFW_KEY_R:
			red = 255;
			green = 0;
			blue = 0;
			break;
		case GLFW_KEY_G:
			red = 0;
			green = 255;
			blue = 0;
			break;
		case GLFW_KEY_B:
			red = 0.0;
			green = 0.0;
			blue = 255;
			break;

		case GLFW_KEY_T:
			modT = !modT;
			break;

			//Разбиение
		case GLFW_KEY_Z:
			Amount += 1;
			break;
		case GLFW_KEY_X:
			Amount -= 1;
			break;


		case GLFW_KEY_PAGE_UP:
			floors++;
			break;
		case GLFW_KEY_PAGE_DOWN:
			floors--;
			break;
		}
	}
}

void makeTexture(float xCenterUp, float yCenterUp, float xCenterDown, float yCenterDown,
	float length, float rx, float ry, float pointCount) {
	if (pointCount < 3) pointCount = 3;
	const float step = float(2 * M_PI) / pointCount;

	float dx1 = 0, dy1 = 0, dx2 = 0, dy2 = 0;
	float dx1temp = 0, dy1temp = 0, dx2temp = 0, dy2temp = 0;
	float xCenterUpTemp = 0;
	float yCenterUpTemp = 0;

	float angle = 0;

	float len = length / 2;

	GLint i = 1;

	glPolygonMode(GL_FRONT_AND_BACK, IS_FILL ? GL_FILL : GL_LINE);
	glFrontFace(GL_CW);
	glColor3d(1, 1, 1);

	for (float angle = 0; angle <= float(2 * M_PI); angle += step) {
		dx1 = rx * cosf(angle);
		dy1 = ry * sinf(angle);
		dx2 = rx * cosf(angle + step);
		dy2 = ry * sinf(angle + step);


		//glBindTexture(GL_TEXTURE_2D, textureID);
		glBegin(GL_TRIANGLES);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f(xCenterDown, yCenterDown, -len); // Бок
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f(dx1 + xCenterUp, dy1 + yCenterUp, len);
		glTexCoord2f(0.5f, 1.0f);
		glVertex3f(dx2 + xCenterUp, dy2 + yCenterUp, len);
		glEnd();
		//glBindTexture(GL_TEXTURE_2D, 0);

		glColor3d(0, 1, 0); // Основание

		glBegin(GL_TRIANGLES);
		//glTexCoord2f(0.0f, 0.0f);
		glVertex3f(xCenterUp, yCenterUp, len);
		//glTexCoord2f(1.0f, 0.0f);
		glVertex3f(dx1 + xCenterUp, dy1 + yCenterUp, len);
		//glTexCoord2f(0.5f, 1.0f);
		glVertex3f(dx2 + xCenterUp, dy2 + yCenterUp, len);
		glEnd();


	}
	glDisable(GL_TEXTURE_2D);


}


void makeLight() {
	float light0_diffuse[] = { 0.8f, 0.8f, 0.8f };
	float light0_position[] = { -390, 290, 300, 1.0 };
	float light0_ambient[] = { 0.5, 0.5, 0.5, 1.0 };
	//float specular[] = { 1.0f, 1.0f, 1.0f, 1.0f};
	float light0_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
	float ambient[] = { 0.5f, 0.2f, 0.2f, 1.0f };
	float default_amb[] = { 0.2f, 0.2f, 0.2f, 1.0f };
	glEnable(GL_NORMALIZE);
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
	if (global_ambient)
		glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
	else
		glLightModelfv(GL_LIGHT_MODEL_AMBIENT, default_amb);
	if (two_side)
		glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
	else
		glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
	if (local_viewer)
		glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
	else
		glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE);

	glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
	glLightfv(GL_LIGHT0, GL_SPECULAR, light0_specular);
	glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
}


void save() {
	std::ofstream t;
	t.open("./textfile.txt");
	if (t.is_open()) {
		t << "movex = (" << MOVE_X << ") movey = (" << MOVE_Y << ") movez = (" << MOVE_Z
			<< ") rotatex = (" << ROTATE_X << ") rotatey = (" << ROTATE_Y << ") rotatez = (" << ROTATE_Z << ")"
			<< ") amount = (" << Amount << ") size = (" << SIZE << ") floors = (" << floors << ")";
	}
}

void DrawFigure(float xCenterUp, float yCenterUp, float xCenterDown, float yCenterDown,
	float length, float rx, float ry, float pointCount) {
	glBindTexture(GL_TEXTURE_2D, textureID);



	//glEnable(GL_TEXTURE_2D);
	//glBindTexture(GL_TEXTURE_2D, textureID);

	if (pointCount < 3) pointCount = 3;
	const float step = float(2 * M_PI) / pointCount;

	float dx1 = 0, dy1 = 0, dx2 = 0, dy2 = 0;
	float dx1temp = 0, dy1temp = 0, dx2temp = 0, dy2temp = 0;
	float xCenterUpTemp = 0;
	float yCenterUpTemp = 0;

	float angle = 0;

	float len = length / 2;

	GLint i = 1;

	glPolygonMode(GL_FRONT_AND_BACK, IS_FILL ? GL_FILL : GL_LINE);

	for (float angle = 0; angle <= float(2 * M_PI); angle += step) {
		dx1 = rx * cosf(angle);
		dy1 = ry * sinf(angle);
		dx2 = rx * cosf(angle + step);
		dy2 = ry * sinf(angle + step);

		for (GLint i = 1; i < floors; i++) {
			dx1temp = (dx1 / floors) * (floors - i);
			dx2temp = (dx2 / floors) * (floors - i);
			dy1temp = (dy1 / floors) * (floors - i);
			dy2temp = (dy2 / floors) * (floors - i);
			xCenterUpTemp = -(xCenterDown / floors) * (floors - i) + xCenterDown;
			yCenterUpTemp = -(yCenterDown / floors) * (floors - i) + yCenterDown;


			glColor3d(0, 1, 0); //Основание
								//glBindTexture(GL_TEXTURE_2D, textureID);
			glBegin(GL_TRIANGLES);
			//glTexCoord2f(0.0f, 0.0f);
			glVertex3f(xCenterUpTemp, yCenterUpTemp, len - length / floors * i);
			//glTexCoord2f(1.0f, 0.0f);
			glVertex3f(dx1temp + xCenterUpTemp, dy1temp + yCenterUpTemp, len - length / floors * i);
			//glTexCoord2f(0.5f, 1.0f);
			glVertex3f(dx2temp + xCenterUpTemp, dy2temp + yCenterUpTemp, len - length / floors * i);
			glEnd();
		}
		glColor3d(1, 1, 1);
		glBegin(GL_TRIANGLES);
		//glTexCoord2f(0.0f, 0.0f);
		glVertex3f(xCenterDown, yCenterDown, -len); // Бок
													//glTexCoord2f(1.0f, 0.0f);
		glVertex3f(dx1 + xCenterUp, dy1 + yCenterUp, len);
		//glTexCoord2f(0.5f, 1.0f);
		glVertex3f(dx2 + xCenterUp, dy2 + yCenterUp, len);
		glEnd();

		//glColor3d(0, 1, 0); // Основание
		//glBindTexture(GL_TEXTURE_2D, textureID);
		glBegin(GL_TRIANGLES);
		//glTexCoord2f(0.0f, 0.0f);
		glVertex3f(xCenterUp, yCenterUp, len);
		//glTexCoord2f(1.0f, 0.0f);
		glVertex3f(dx1 + xCenterUp, dy1 + yCenterUp, len);
		//glTexCoord2f(0.5f, 1.0f);
		glVertex3f(dx2 + xCenterUp, dy2 + yCenterUp, len);
		glEnd();

	}
	//glDisable(GL_TEXTURE_2D);


}


void display(GLFWwindow * window)
{
	int width, height;

	glfwGetFramebufferSize(window, &width, &height);

	//Static cube

	glViewport(0, 0, width / 2, height / 2);
	glEnable(GL_DEPTH_TEST);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(-width, width, -height, height, -1000, 1000);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	//Подключение текстуры

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glPushMatrix();
	glTranslatef(-1000, -350, 300);
	glRotatef(-20, 1, 0, 0);
	glRotatef(-20, 0, 1, 0);
	//DrawObjects(3);
	glPopMatrix();

	//projection Ozy Вверху слева

	glViewport(0, height / 2 + 1, width / 2 + 1, height / 2);
	glEnable(GL_DEPTH_TEST);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(-width, width, -height, height, -1000, 1000);
	glRotatef(90, 1, 0, 0);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glTranslatef(-200, -200, 500);
	glTranslatef(MOVE_X + 350, MOVE_Y + 350, MOVE_Z - 500);
	glScaled(SIZE, SIZE, SIZE);
	glRotatef(ROTATE_X, 1, 0, 0);
	glRotatef(ROTATE_Y, 0, 1, 0);
	glRotatef(ROTATE_Z, 0, 0, 1);
	DrawFigure(0, 0, 30, 30, 200, 50, 100, Amount);
	//drawAxis(250, 150, -450);

	//projection Oxy Вверху справа

	glViewport(width / 2 + 1, height / 2 + 1, width / 2, height / 2);
	glEnable(GL_DEPTH_TEST);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(-width, width, -height, height, -1000, 1000);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glTranslatef(MOVE_X, MOVE_Y, MOVE_Z - 500);
	glScaled(SIZE, SIZE, SIZE);
	glRotatef(ROTATE_X, 1, 0, 0);
	glRotatef(ROTATE_Y, 0, 1, 0);
	glRotatef(ROTATE_Z, 0, 0, 1);
	DrawFigure(0, 0, 30, 30, 200, 50, 100, Amount);

	//projection Oxz Внизу справа

	glViewport(width / 2 + 1, 0, width / 2, height / 2);
	glEnable(GL_DEPTH_TEST);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(-width, width, -height, height, -1000, 1000);
	glRotatef(90, 0, 1, 0);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glTranslatef(-200, -200, 500);
	glTranslatef(MOVE_X + 350, MOVE_Y + 350, MOVE_Z - 500);
	glScaled(SIZE, SIZE, SIZE);
	glRotatef(ROTATE_X, 1, 0, 0);
	glRotatef(ROTATE_Y, 0, 1, 0);
	glRotatef(ROTATE_Z, 0, 0, 1);
	//DrawFigure(0, 0, 30, 30, 200, 50, 100, Amount);
	glEnable(GL_TEXTURE_2D);
	makeTexture(0, 0, 30, 30, 200, 50, 100, Amount);
}

int main()
{
	if (!glfwInit())
		exit(1);

	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);

	GLFWwindow * window = glfwCreateWindow(800, 600, "Laba", NULL, NULL);
	if (!window)
	{
		glfwTerminate();
		exit(1);
	}

	glfwMakeContextCurrent(window);
	glfwSetKeyCallback(window, key);

	makeLight();

	int w = 512, h = 512;
	unsigned char* image = SOIL_load_image("./met.bmp", &w, &h, 0, SOIL_LOAD_RGB);
	glGenTextures(1, &textureID);
	glBindTexture(GL_TEXTURE_2D, textureID);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
	SOIL_free_image_data(image);
	glBindTexture(GL_TEXTURE_2D, 0);


	while (!glfwWindowShouldClose(window)) {

		if (modT) {
			glEnable(GL_TEXTURE_2D);
		}
		else {
			glDisable(GL_TEXTURE_2D);
		}
		display(window); //рисует
		glfwSwapBuffers(window); //Меняет буферы
		glfwPollEvents(); //Слушает нажатия
	}
	glfwDestroyWindow(window);
	glfwTerminate();

	return 0;
}