using namespace std;

#define GLEW_STATIC
#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include <iostream>
#include <vector>
#include <string.h>
#include <complex>
#include <fstream>
#include <pthread.h>
#include <unistd.h>

const char *vertex = R"(
	#version 330 core
	layout (location = 0) in vec3 position;
	layout (location = 1) in vec3 color;
	layout (location = 2) in vec2 texCoord;

	out vec3 ourColor;
	out vec2 TexCoord;

	void main() {
		gl_Position = vec4(position, 1.0f);
		ourColor = color;
		TexCoord = texCoord;
	}
)";

const char *fragment = R"(
	#version 330 core

	uniform vec2 screenSize;
	uniform sampler2D image;

	in vec3 ourColor;
	in vec2 TexCoord;

	out vec4 color;

	uniform sampler2D ourTexture;

	void main() {
		color = texture(ourTexture, TexCoord);
	}
)";

GLuint compileShader(GLenum shaderType, const char* source) {
	GLuint shader = glCreateShader(shaderType);
	if (shader) {
		glShaderSource(shader, 1, &source, NULL);
		glCompileShader(shader);
		GLint status = 0;
		glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
		if (!status) {
			GLint log_len;
			glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_len);
			if (log_len > 0) {
				vector<char> message(log_len + 1);
				glGetShaderInfoLog(shader, log_len, NULL, &message[0]);
				printf("%s\n", &message[0]);
			}
			glDeleteShader(shader);
			shader = 0;
		}
	}
	return shader;
}

GLuint createShader(const char* vertexSource, const char* fragmentSource) {
	GLuint vertexShader = compileShader(GL_VERTEX_SHADER, vertexSource);
	if (!vertexShader) return 0;

	GLuint pixelShader = compileShader(GL_FRAGMENT_SHADER, fragmentSource);
	if (!pixelShader) return 0;

	GLuint program = glCreateProgram();
	if (program) {
		glAttachShader(program, vertexShader);
		glAttachShader(program, pixelShader);
		glLinkProgram(program);
		GLint status = GL_FALSE;
		glGetProgramiv(program, GL_LINK_STATUS, &status);
		if (status != GL_TRUE) {
			GLint log_len;
			glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_len);
			if (log_len > 0) {
				vector<char> message(log_len + 1);
				glGetProgramInfoLog(program, log_len, NULL, &message[0]);
				printf("%s\n", &message[0]);
			}
			glDeleteProgram(program);
			program = 0;
		}
	}
	return program;
}

struct Color {
	unsigned char r, g, b;
};

struct TextureData {
	GLuint bufferId;
	int width, height;
	Color *pixels;

	TextureData(int width, int height) : width(width), height(height) {
		pixels = new Color[width * height];
		glGenTextures(1, &bufferId);
		glBindTexture(GL_TEXTURE_2D, bufferId);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glBindTexture(GL_TEXTURE_2D, 0);

		apply();
	}

	void apply() {
		//glTexSubImage2D(GL_TEXTURE_2D, 0 ,0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid*)screenData);
		glBindTexture(GL_TEXTURE_2D, bufferId);
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, pixels);
		glBindTexture(GL_TEXTURE_2D, 0);
	}

	~TextureData() {
		delete[] pixels;
	}

	Color getPixel(int x, int y) {
		return pixels[y * width + x];
	}

	void setPixel(int x, int y, Color color) {
		pixels[y * width + x] = color;
	}
};


enum { pallete_size = 64 };
unsigned char pallete[pallete_size][3];

bool update = false;
bool running = true;

int width, height;
int t = 0;

float aspect, scale, offsetX, offsetY;

void update_pixels(TextureData *texture) {
	for (int y = 0; y < height; ++y) {
		for (int x = 0; x < width; ++x) {
			complex<double> c(x * scale - offsetX, y * scale - offsetY);
			complex<double> z(0.0, 0.0);

			int n = 0;
			while (n < (t % pallete_size)) {
				z = z * z + c;
				if (abs(z) > 2.0) break;
				++n;
			}
			unsigned char r = pallete[n][0];
			unsigned char g = pallete[n][1];
			unsigned char b = pallete[n][2];

			texture->setPixel(x, y, Color{r, g, b});
		}
	}
	t++;
}

void *update_texture(void *ptr) {
	TextureData *texture = (TextureData *)ptr;

	while (running) {
		if (update) continue;
		update_pixels(texture);
		update = true;
		//cout << "update" << endl;
	}
}

int main() {
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

	GLFWwindow* window = glfwCreateWindow(800, 600, "Computer graphics", nullptr, nullptr);
	if (window == nullptr) {
		cout << "Failed to create GLFW window" << endl;
		glfwTerminate();
		return 0;
	}
	glfwMakeContextCurrent(window);

	glewExperimental = GL_TRUE;
	if (glewInit() != GLEW_OK) {
		cout << "Failed to initialize GLEW" << endl;
		return 0;
	}

	glfwGetFramebufferSize(window, &width, &height);
	glViewport(0, 0, width, height);

	auto shader = createShader(vertex, fragment);

	aspect = (float) width / (float) height;

	scale = 4.0 / (float) height;
	offsetX = aspect * 2.0;
	offsetY = 2.0;

	GLfloat vertices[] = {
		// Positions		  // Colors		   // Texture Coords
		 1,  1, 0.0f,   1.0f, 0.0f, 0.0f,   1.0f, 1.0f, // Top Right
		 1, -1, 0.0f,   0.0f, 1.0f, 0.0f,   1.0f, 0.0f, // Bottom Right
		-1, -1, 0.0f,   0.0f, 0.0f, 1.0f,   0.0f, 0.0f, // Bottom Left
		-1,  1, 0.0f,   1.0f, 1.0f, 0.0f,   0.0f, 1.0f  // Top Left
	};
	GLuint indices[] = {  // Note that we start from 0!
		0, 1, 3, // First Triangle
		1, 2, 3  // Second Triangle
	};
	GLuint VBO, VAO, EBO;
	glGenVertexArrays(1, &VAO);
	glGenBuffers(1, &VBO);
	glGenBuffers(1, &EBO);

	glBindVertexArray(VAO);

	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

	// Position attribute
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
	glEnableVertexAttribArray(0);
	// Color attribute
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
	glEnableVertexAttribArray(1);
	// TexCoord attribute
	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));
	glEnableVertexAttribArray(2);
	glBindVertexArray(0); // Unbind VAO


	TextureData texture(width, height);
	glUseProgram(shader);
	glUniform2f(glGetUniformLocation(shader, "screenSize"), width, height);

	for (int i = 0; i < pallete_size; i++) {
		pallete[i][0] = i < (2 * pallete_size / 3) ? (i * 255 * 3 / (2 * pallete_size)) : 255;
		pallete[i][1] = i < pallete_size / 3 ? 0 : (i  - pallete_size / 3) * 255 * 3 / (2 * pallete_size);
		pallete[i][2] = 0;
	}

	t = 0;

	bool use_multithread = false;

	pthread_t thread;
	if (use_multithread) {
		update = false;
		running = true;
		pthread_create(&thread, NULL, update_texture, &texture);
	}

	while(!glfwWindowShouldClose(window)) {
		glfwPollEvents();

		glClearColor(0, 0, 1, 1);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		//update_texture(&texture);

		if (use_multithread) {
			if (update == true) {
				texture.apply();
				update = false;
				//cout << "end update" << endl;
			}
		} else {
			update_pixels(&texture);
			texture.apply();
		}

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, texture.bufferId);
		glUniform1i(glGetUniformLocation(shader, "ourTexture"), 0);

		// Draw container
		glBindVertexArray(VAO);
		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
		glBindVertexArray(0);

		glfwSwapBuffers(window);
	}
	if (use_multithread) {
	running = false;
	pthread_join(thread, NULL);
}
	glUseProgram(0);
	glfwTerminate();
	return 0;
	//pthread_join(thread, NULL);
}