#include <GL/glew.h>
#include <glm/glm.hpp>
#include <glm/gtx/transform.hpp>
#include <glm/gtc/matrix_transform.hpp>

#include <cstdio>

#include "Game.h"
#include "CShaderLoader.h"

GLuint program, vertexShader, fragmentShader, vbo, vao, ebo;

void loadShaders() {
	CShaderLoader vertexLoader = ("C:/opengl/shaders/shader.vert");
	CShaderLoader fragmentLoader = ("C:/opengl/shaders/shader.frag");
	const char* vertexSource = vertexLoader.loadFileToString();
	const char* fragmentSource = fragmentLoader.loadFileToString();

	vertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertexShader, 1, &vertexSource, 0);
	glCompileShader(vertexShader);

	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragmentShader, 1, &fragmentSource, 0);
	glCompileShader(fragmentShader);

	program = glCreateProgram();
	glAttachShader(program, vertexShader);
	glAttachShader(program, fragmentShader);
	glBindFragDataLocation(program, 0, "color");
	glLinkProgram(program);
	glUseProgram(program);
}

void reportShaderErrors() {
	GLchar buffer[512];
	GLint status;

	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status);
	glGetShaderInfoLog(vertexShader, 512, NULL, buffer);
	printf("Vertex Shader Compile Errors:\n%s\n", buffer);

	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &status);
	glGetShaderInfoLog(fragmentShader, 512, NULL, buffer);
	printf("Fragment Shader Compile Errors:\n%s\n", buffer);
}

void loadData() {
	GLfloat vertices[] = {
		-1.0f, +1.0f, -1.0f,	//Vertex 1
		1.0f, 0.0f, 0.0f,

		-1.0f, -1.0f, -1.0f,	//Vertex 2
		0.0f, 1.0f, 0.0f,

		+1.0f, -1.0f, -1.0f,	//Vertex 3
		0.0f, 0.0f, 1.0f,

		+1.0f, +1.0f, -1.0f,	//Vertex 4
		1.0f, 1.0f, 1.0f,
	};

	glGenBuffers(1, &vbo);
	glBindBuffer(GL_ARRAY_BUFFER, vbo);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

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

	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), 0);
	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));

	GLuint indices[] = {
		0, 1, 2,	//front
		2, 3, 0,
	};

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

void mvp() {
	glm::mat4 model = glm::mat4(1.0f);
	glm::mat4 view = glm::lookAt(
		glm::vec3(4.0f, 3.0f, 3.0f),
		glm::vec3(0.0f, 0.0f, 0.0f),
		glm::vec3(0.0f, 1.0f, 0.0f)
	);
	glm::mat4 projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
	glm::mat4 mvp = projection * view * model;

	GLuint matrixID = glGetUniformLocation(program, "MVP");
	glUniformMatrix4fv(matrixID, 1, GL_FALSE, &mvp[0][0]);
}

void Game::initialize() {
	glewExperimental = GL_TRUE;
	glewInit();
	glEnable(GL_DEPTH_TEST);

	loadData();
	mvp();
	loadShaders();
	reportShaderErrors();
}

void Game::paint() {
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
}

#version 330

layout(location=0) in vec3 position;
layout(location=1) in vec3 vertColor;

out vec3 fragColor;

uniform mat4 MVP;

void main()
{
	fragColor = vertColor;
	gl_Position = MVP * vec4(position, 1.0);
}