/* Simplified OpenGL 4.5 demo
 * Seth Long, Fall 2020
 * This is a *very* short demo which displays a triangle
 * Many of these functions can fail, and return error values
 * I doubt it can be done much shorter without leaving vertices in only main memory or some such
 */

#include<stdio.h>
#include<stdlib.h>
#include<fcntl.h>
#include<unistd.h>
#include<GL/glew.h>
#include<GLFW/glfw3.h>
#include<glm/glm.hpp>
#include<glm/gtc/matrix_transform.hpp>
#include<glm/gtc/type_ptr.hpp>
#include "scolor.hpp"

using namespace glm;

float height = 1080;
float width = 1920;

// Will be used for a lot of stuff throughout the demo
// NOTE:  general_buffer is NOT thread safe.  Don't try to load shaders in parallel!
// NOTE on the NOTE:  You probably shouldn't do that anyway!
#define GBLEN (1024*32)
char *general_buffer;

GLuint make_shader(const char *filename, GLenum shaderType){
	int fd = open(filename, O_RDONLY);
	size_t readlen = read(fd, general_buffer, GBLEN);
	close(fd);
	if(readlen == GBLEN){
		printf(RED("Buffer Length of %d bytes Inadequate for File %s\n").c_str(), GBLEN, filename);
		return 0;
	}
	general_buffer[readlen] = 0;
	printf(DGREEN("Read shader in file %s (%d bytes)\n").c_str(), filename, readlen);
	puts(general_buffer);
	unsigned int s_reference = glCreateShader(shaderType);
	glShaderSource(s_reference, 1, (const char**)&general_buffer, 0);
	glCompileShader(s_reference);
	glGetShaderInfoLog(s_reference, GBLEN, NULL, general_buffer);
	puts(general_buffer);
	GLint compile_ok;
	glGetShaderiv(s_reference, GL_COMPILE_STATUS, &compile_ok);
	if(compile_ok){
		puts(GREEN("Compile Success").c_str());
		return s_reference;
	}
	puts(RED("Compile Failed\n").c_str());
	return 0;
}

GLuint make_program(const char* v_file, const char* tcs_file, const char* tes_file, const char* g_file, const char* f_file){
	unsigned int vs_reference = make_shader(v_file, GL_VERTEX_SHADER);
	unsigned int tcs_reference = 0, tes_reference = 0;
	if(tcs_file)
		if(!(tcs_reference = make_shader(tcs_file, GL_TESS_CONTROL_SHADER)))
			return 0;
	if(tes_file)
		if(!(tes_reference = make_shader(tes_file, GL_TESS_EVALUATION_SHADER)))
			return 0;
	unsigned int gs_reference = 0;
	if(g_file)
		gs_reference = make_shader(g_file, GL_GEOMETRY_SHADER);
	unsigned int fs_reference = make_shader(f_file, GL_FRAGMENT_SHADER);
	if(!(vs_reference && fs_reference))
		return 0;
	if(g_file && !gs_reference)
		return 0;


	unsigned int program = glCreateProgram();
	glAttachShader(program, vs_reference);
	if(g_file)
		glAttachShader(program, gs_reference);
	if(tcs_file)
		glAttachShader(program, tcs_reference);
	if(tes_file)
		glAttachShader(program, tes_reference);
	glAttachShader(program, fs_reference);
	glLinkProgram(program);
	GLint link_ok;
	glGetProgramiv(program, GL_LINK_STATUS, &link_ok);
	if(!link_ok){
		glGetProgramInfoLog(program, GBLEN, NULL, general_buffer);
		puts(general_buffer);
		puts(RED("Link Failed").c_str());
		return 0;
	}

	return program;
}

void resize(GLFWwindow*, int new_width, int new_height){
	width = new_width;
	height = new_height;
	printf("Window resized, now %f by %f\n", width, height);
	glViewport(0, 0, width, height);
}

int main(int argc, char ** argv){
	general_buffer = (char*)malloc(GBLEN);
	glfwInit();
	GLFWwindow* window = glfwCreateWindow(width, height, "Simple OpenGL 4.0+ Demo", 0, 0);
	glfwSetFramebufferSizeCallback(window, resize);	
	glfwMakeContextCurrent(window);
	glewInit();

	// Initialization part
	float vertices[] = {
		// front
		-1.0, -1.0,  1.0,
		1.0, -1.0,  1.0,
		1.0,  1.0,  1.0,
		-1.0,  1.0,  1.0,
		// back
		-1.0, -1.0, -1.0,
		1.0, -1.0, -1.0,
		1.0,  1.0, -1.0,
		-1.0,  1.0, -1.0,
	};
	unsigned int vbuf;
	glGenBuffers(1, &vbuf);
	glBindBuffer(GL_SHADER_STORAGE_BUFFER, vbuf);
	glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	float colors[] = {
		// front colors
		1.0, 0.0, 0.0,
		0.0, 1.0, 0.0,
		0.0, 0.0, 1.0,
		1.0, 1.0, 1.0,
		// back colors
		1.0, 0.0, 0.0,
		0.0, 1.0, 0.0,
		0.0, 0.0, 1.0,
		1.0, 1.0, 1.0,
	};
	unsigned int cbuf;
	glGenBuffers(1, &cbuf);
	glBindBuffer(GL_SHADER_STORAGE_BUFFER, cbuf);
	glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);

	GLushort cube_elements[] = {
		// front
		0, 1, 2,
		2, 3, 0,
		// top
		1, 5, 6,
		6, 2, 1,
		// back
		7, 6, 5,
		5, 4, 7,
		// bottom
		4, 0, 3,
		3, 7, 4,
		// left
		4, 5, 1,
		1, 0, 4,
		// right
		3, 2, 6,
		6, 7, 3,
	};
	unsigned int ebuf;
	glGenBuffers(1, &ebuf);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebuf);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cube_elements), cube_elements, GL_STATIC_DRAW);

	GLuint program = make_program("vertex_shader.glsl", "tess_control.glsl", "tess_eval.glsl", 0, "fragment_shader.glsl");
	if(!program)
		return 1;

	unsigned int v_attrib = glGetAttribLocation(program, "in_vertex");
	unsigned int c_attrib = glGetAttribLocation(program, "in_color");
	unsigned int mvp_uniform = glGetUniformLocation(program, "mvp");
	unsigned int m_uniform = glGetUniformLocation(program, "model");

	int count = 0;

	glUseProgram(program);

	glEnableVertexAttribArray(v_attrib);
	glBindBuffer(GL_ARRAY_BUFFER, vbuf);
	glVertexAttribPointer(v_attrib, 3, GL_FLOAT, GL_FALSE, 0, 0);

	glEnableVertexAttribArray(c_attrib);
	glBindBuffer(GL_ARRAY_BUFFER, cbuf);
	glVertexAttribPointer(c_attrib, 3, GL_FLOAT, GL_FALSE, 0, 0);

	int size;  
	glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &size);

	glEnable(GL_DEPTH_TEST);
	while(!glfwWindowShouldClose(window)){
		count++;
		glfwPollEvents();
		glClearColor(0, 0, 0, 1.0);
		glClear(GL_COLOR_BUFFER_BIT);
		glClear(GL_DEPTH_BUFFER_BIT);

		glm::vec3 axis_y(0, 1, 0);
		glm::mat4 model = glm::rotate(glm::mat4(1.0f), 1 * count/100.0f, glm::vec3(1, 1, 0));
		glm::mat4 view = glm::lookAt(glm::vec3(0.0f, 0.0f, 4 + (1 * sin(count / 50.0))), glm::vec3(0, 0, 0), axis_y);
		glm::mat4 projection = glm::perspective(45.0f, width/height, 0.1f, 1000.0f);
		glm::mat4 mvp = projection * view * model;

		glUniformMatrix4fv(m_uniform, 1, 0, glm::value_ptr(model));
		glUniformMatrix4fv(mvp_uniform, 1, 0, glm::value_ptr(mvp));

		glPatchParameteri(GL_PATCH_VERTICES, 3);
		glDrawElementsInstanced(GL_PATCHES, size/sizeof(GLushort), GL_UNSIGNED_SHORT, 0, 1);

		{
			mat4 tmodel = translate(mat4(1.0f), vec3(-3, 0, 0));
			tmodel = rotate(tmodel, 1 * count/100.0f, vec3(1, 1, 0));
			mat4 mvp = projection * view * tmodel;

			glUniformMatrix4fv(m_uniform, 1, 0, glm::value_ptr(model));
			glUniformMatrix4fv(mvp_uniform, 1, 0, glm::value_ptr(mvp));

			glPatchParameteri(GL_PATCH_VERTICES, 3);
			glDrawElementsInstanced(GL_PATCHES, size/sizeof(GLushort), GL_UNSIGNED_SHORT, 0, 1);
		}

		glfwSwapBuffers(window);
	}

	glDeleteProgram(program);
	glfwDestroyWindow(window);
	glfwTerminate();
	free(general_buffer);
}
// g++ load_object.cpp -lGL -lglfw -lGLEW