#include <GL/glew.h>
#include <GL/freeglut.h> //includes glu.h and gl.h
#include <glm/mat4x4.hpp>
#include <glm/ext/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>

#include <iostream>

#include <graphics.hpp>

GLuint vbo;	//vertex buffer
GLuint ebo;	//element buffer
GLuint vao;	//vertex array (holds shader relations etc to vertex buffer)

GLuint shader;	//standard shader program used for all elements
GLuint transUniform;	//location of the "transMatrix" transformation matrix uniform in the shader

void display () {
	glClear(GL_COLOR_BUFFER_BIT);

	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

	glutSwapBuffers();
}

void initBuffers () {
	glewInit();

	//TODO: put quad stuff in header file or something
	GLfloat quad[] = {
		//vertex	UV/texcoord
		0.5f, 0.5f,	1.0f, 0.0f,
		0.5f, -0.5f,	1.0f, 1.0f,
		-0.5f, -0.5f,	0.0f, 1.0f,
		-0.5f, 0.5f,	0.0f, 0.0f,
	};

	GLuint quadElements[] = {
		0, 1, 2,
		2, 3, 0
	};

	const char* vsSrc = 
		"#version 150\n"
		"in vec2 position;"
		"in vec2 texcoord;"
		"out vec2 uv;"
		"uniform mat4 transMatrix;"
		"void main () {"
		"gl_Position = transMatrix * vec4(position, 0.0, 1.0);"
		"uv = texcoord;"
		"}";

	const char* fsSrc = 
		"#version 150\n"
		"in vec2 uv;"
		"out vec4 color;"
		"uniform sampler2D tex;"
		"void main () {"
		"color = texture(tex, uv);"
		"}";

	glGenVertexArrays(1, &vao);
	glBindVertexArray(vao);

	glGenBuffers(1, &vbo);
	glBindBuffer(GL_ARRAY_BUFFER, vbo);
	//change to GL_DYNAMIC_DRAW when using deformable meshes
	glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STATIC_DRAW);

	glGenBuffers(1, &ebo);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(quadElements),  quadElements, GL_STATIC_DRAW);

	//compile vert shader
	GLuint vs = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vs, 1, &vsSrc, NULL);
	glCompileShader(vs);
	GLint status;
	glGetShaderiv(vs, GL_COMPILE_STATUS, &status);
	if (status != GL_TRUE) { std::cout << "vertex shader borked" << std::endl;
				 printShaderCompileLog(vs); }

	//compile frag shader
	GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fs, 1, &fsSrc, NULL);
	glCompileShader(fs);
	glGetShaderiv(fs, GL_COMPILE_STATUS, &status);
	if (status != GL_TRUE) { std::cout << "fragment shader borked" << std::endl;
				 printShaderCompileLog(vs); }

	
	//link shaders into a shader program
	shader = glCreateProgram();
	glAttachShader(shader, vs);
	glAttachShader(shader, fs);
	glBindFragDataLocation(shader, 0, "color");
	glLinkProgram(shader);
	glUseProgram(shader);


	//tell OpenGL what to put in the input vars
	GLuint posAttr = glGetAttribLocation(shader, "position");
	glVertexAttribPointer(posAttr, 2, GL_FLOAT, GL_FALSE, 4*sizeof(GLfloat), 0);
	glEnableVertexAttribArray(posAttr);
	GLuint uvAttr = glGetAttribLocation(shader, "texcoord");
	glVertexAttribPointer(uvAttr, 2, GL_FLOAT, GL_FALSE, 4*sizeof(GLfloat), (void*)(2*sizeof(GLfloat)));
	glEnableVertexAttribArray(uvAttr);

	transUniform = glGetUniformLocation(shader, "transMatrix");
	glUniformMatrix4fv(transUniform, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f)));

	GLuint tex;
	glGenTextures(1, &tex);
	glBindTexture(GL_TEXTURE_2D, tex);

	int x, y, channels;
	GLubyte* pixels = stbi_load("face.png", &x, &y, &channels, 4);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, x, y, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	//enable blending for alpha textures
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}

void initGraphics () {
	int argc = 1;
	char *argv[1] = {(char*)"fc2d"};

	glutInit(&argc, argv);
	glutCreateWindow("FaceCam2D");
	glutInitWindowSize(512, 512);
	glutDisplayFunc(display);

	initBuffers();

	glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
}

void graphicsFrame () {
	glutMainLoopEvent();
}

void printShaderCompileLog(GLuint shader) {
	char logBuffer[1024];
	glGetShaderInfoLog(shader, 1024, NULL, logBuffer);
	std::cout << "Compile log for shader " << shader << std::endl;
	std::cout << logBuffer << std::endl;
}

void initModel () {

}

void updateModel(glm::vec2 headPos) {
	//calculate transform
	glm::mat4 transMatrix = glm::translate(glm::mat4(1.0f), glm::vec3(headPos.x, headPos.y, 0.0f));

	//upload to GPU and put in transMatrix uniform var in shader program
	glUniformMatrix4fv(transUniform, 1, GL_FALSE, glm::value_ptr(transMatrix));

	glutPostRedisplay();
}