#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <cassert>

#include "src/standard_ints.h"
#include "src/lgl_callbacks.h"
#include "src/lgl_shader_tools.h"

int main(void) {

	std::cout << "Hello World." << std::endl;

	// Setup GLFW context
	glfwInit();

	// Establish 4.2 GL requirement
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	// Build the winodw
	GLFWwindow *window = glfwCreateWindow(960, 400, 
		"Hello MyBox", NULL, NULL);
	glfwSetWindowPos(window, 140, 1000);

	if (window == NULL) {
		std::cout << "Failed to create GLFW window." << std::endl;
		glfwTerminate();
		return -1;
	}

	glfwMakeContextCurrent(window);
	// Set the resize callback;
	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

	// Setup the glad loader
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
		std::cout << "Failed to initalize GLAD." << std::endl;
		return -1;
	}

	/* ====================================================================== */
	/* ====================================================================== */
	/* ====================================================================== */
	i32 success;
	char infoLog[512];

	// Create the vertex shader
	GLchar *shdr_src_vertex;
	readshader("vertex.vert", &shdr_src_vertex);
	u32 vertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertexShader, 1, &shdr_src_vertex, NULL);
	glCompileShader(vertexShader);
	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
	freeshader(shdr_src_vertex);

	if (!success) {
		glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
		std::cout << "ERROR SHADER::VERTEX::Compilation Failed\n" << 
			infoLog << std::endl;
		return -1;
	}

	// Create the fragment shader
	GLchar *shdr_src_fragment;
	readshader("fragment.frag", &shdr_src_fragment);
	u32 fragmentShader[2] = {
		glCreateShader(GL_FRAGMENT_SHADER),
		glCreateShader(GL_FRAGMENT_SHADER)
	};
	glShaderSource(fragmentShader[0], 1, &shdr_src_fragment, NULL);
	glCompileShader(fragmentShader[0]);
	glGetShaderiv(fragmentShader[0], GL_COMPILE_STATUS, &success);
	freeshader(shdr_src_fragment);
	if (!success) {
		glGetShaderInfoLog(fragmentShader[0], 512, NULL, infoLog);
		std::cout << "ERROR SHADER::FRAGMENT::Compilation Failed\n" << 
			infoLog << std::endl;
		return -1;
	}

	readshader("fragment2.frag", &shdr_src_fragment);
	glShaderSource(fragmentShader[1], 1, &shdr_src_fragment, NULL);
	glCompileShader(fragmentShader[1]);
	glGetShaderiv(fragmentShader[1], GL_COMPILE_STATUS, &success);
	freeshader(shdr_src_fragment);
	if (!success) {
		glGetShaderInfoLog(fragmentShader[1], 512, NULL, infoLog);
		std::cout << "ERROR SHADER::FRAGMENT::Compilation Failed\n" << 
			infoLog << std::endl;
		return -1;
	}

	// Create the shader program
	u32 shaderProgram[2] = {glCreateProgram(), glCreateProgram()};
	glAttachShader(shaderProgram[0], vertexShader);
	glAttachShader(shaderProgram[1], vertexShader);
	glAttachShader(shaderProgram[0], fragmentShader[0]);
	glAttachShader(shaderProgram[1], fragmentShader[1]);

	glLinkProgram(shaderProgram[0]);
	glGetProgramiv(shaderProgram[0], GL_LINK_STATUS, &success);
	if (!success) {
		glGetProgramInfoLog(shaderProgram[0], 512, NULL, infoLog);
		std::cout << "ERROR SHADER::PROGRAM::Linking Failed\n" << 
			infoLog << std::endl;
		return -1;
	}
	glLinkProgram(shaderProgram[1]);
	glGetProgramiv(shaderProgram[1], GL_LINK_STATUS, &success);
	if (!success) {
		glGetProgramInfoLog(shaderProgram[1], 512, NULL, infoLog);
		std::cout << "ERROR SHADER::PROGRAM::Linking Failed\n" << 
			infoLog << std::endl;
		return -1;
	}

	// Free the old shader bits
	glDeleteShader(vertexShader);
	glDeleteShader(fragmentShader[0]);
	glDeleteShader(fragmentShader[1]);

	/* ====================================================================== */
	/* ====================================================================== */

	// Define the vertex shader dat.
	f32 vertices_1[] = {
		-0.9f, -0.66f, 0.0f,
		-0.1f, -0.66f, 0.0f,
		-0.50f, +0.66f, 0.0f
	};
	f32 vertices_2[sizeof(vertices_1)/sizeof(f32)];
	for (u32 i = 0; i < sizeof(vertices_1)/sizeof(f32); i++) {
		if (i % 3 == 0) {
			vertices_2[i] = -1*vertices_1[i];
		} else {
			vertices_2[i] = vertices_1[i];
		}
	}
	u32 indicies[] {
		0, 1, 2,	// t1
	};
	u32 VAO[2]; // Vertex Array Object refernce number
	glGenVertexArrays(2, VAO); // ask the GPU for a reference for one buffer
	u32 VBO[2]; // Vertex Buffer Object refernce number
	glGenBuffers(2, VBO); // ask the GPU for a reference for one buffer
	u32 EBO; // 
	glGenBuffers(1, &EBO); // ask the gpu for a reference for one buffer
	
	// Bind VAO, meaning we 
	glBindVertexArray(VAO[0]); 
	// Tell the GPU subsequent calls to modify buffers apply to this buffer, 
	// namely, the VBO buffer.
	glBindBuffer(GL_ARRAY_BUFFER, VBO[0]);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_1), vertices_1, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(f32), (void *)0);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indicies), indicies, GL_STATIC_DRAW);
	// For the current Generic Vertex Attirbute Array object (VAO), indicate
	// what index we should be starting in for subsequent draw calls.
	glEnableVertexAttribArray(0);

	glBindVertexArray(VAO[1]); 
	glBindBuffer(GL_ARRAY_BUFFER, VBO[1]);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_2), vertices_2, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(f32), (void *)0);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indicies), indicies, GL_STATIC_DRAW);

	// For the VAO array (theoretically, but we have an array of 1), start
	// at the 0th element of the VAO array.
	glEnableVertexAttribArray(0);

	// Setup the indexing into the VBO data. The EBO is the indirection buffer
	// that tells the GPU where to look into it's known GL_ARRAY_BUFFER object
	// for data.

	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	// ??

	glBindVertexArray(0); // i.e., UNBIND the vertex array.

	
	while(!glfwWindowShouldClose(window)) {
		processInput(window);
		
		// Do some rendering
		glClearColor(0.0f, 0.1f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);

		glUseProgram(shaderProgram[0]);
		glBindVertexArray(VAO[0]);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glUseProgram(shaderProgram[1]);
		glBindVertexArray(VAO[1]);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		//glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0);

		// Finish up
		glfwSwapBuffers(window);
		glfwPollEvents();
	}

	glDeleteVertexArrays(2, VAO);
	glDeleteBuffers(2, VBO);
	glDeleteBuffers(1, &EBO);
	glDeleteProgram(shaderProgram[0]);
	glDeleteProgram(shaderProgram[1]);

	i32 xpos, ypos;
	glfwGetWindowPos(window, &xpos, &ypos);
	std::cout << "Closed window at pos`ition\n  (X,Y) = "
		<< xpos << ", " << ypos << "\n" << std::endl;

	glfwTerminate();
	return 0;
}