#include "glew.h"
#include "glfw3.h"
#include "glm\glm.hpp"
#include "glm\gtc\matrix_transform.hpp"
#include "glm\gtx\transform.hpp"
#include <vector>
#include <string>
#include <fstream>

GLuint CreateShader(GLenum a_eShaderType, const char *a_strShaderFile)
{
	std::string strShaderCode;
	//open shader file
	std::ifstream shaderStream(a_strShaderFile);
	//if that worked ok, load file line by line
	if(shaderStream.is_open())
	{
		std::string Line = "";
		while(std::getline(shaderStream, Line))
		{
			strShaderCode += "\n" + Line;
		}
		shaderStream.close();
	}

	//convert to cstring
	char const *szShaderSourcePointer = strShaderCode.c_str();

	//create shader ID
	GLuint uiShader = glCreateShader(a_eShaderType);
	//load source code
	glShaderSource(uiShader, 1, &szShaderSourcePointer, NULL);

	//compile shader
	glCompileShader(uiShader);

	//check for compilation errors and output them
	GLint iStatus;
	glGetShaderiv(uiShader, GL_COMPILE_STATUS, &iStatus);
	if (iStatus == GL_FALSE)
	{
		GLint infoLogLength;
		glGetShaderiv(uiShader, GL_INFO_LOG_LENGTH, &infoLogLength);

		GLchar *strInfoLog = new GLchar[infoLogLength + 1];
		glGetShaderInfoLog(uiShader, infoLogLength, NULL, strInfoLog);

		const char *strShaderType = NULL;
		switch(a_eShaderType)
		{
		case GL_VERTEX_SHADER: strShaderType = "vertex"; break;
		case GL_FRAGMENT_SHADER: strShaderType = "fragment"; break;
		}

		fprintf(stderr, "Compile failure in %s shader:\n%s\n", strShaderType, strInfoLog);
		delete[] strInfoLog;
	}

	return uiShader;
}

GLuint CreateProgram(const char *a_vertex, const char *a_frag)
{
	std::vector<GLuint> shaderList;

	shaderList.push_back(CreateShader(GL_VERTEX_SHADER, a_vertex));
	shaderList.push_back(CreateShader(GL_FRAGMENT_SHADER, a_frag));

	//create shader program ID
	GLuint uiProgram = glCreateProgram();

	//attach shaders
	for(auto shader = shaderList.begin(); shader != shaderList.end(); shader++)
		glAttachShader(uiProgram, *shader);

	//link program
	glLinkProgram(uiProgram);

	//check for link errors and output them
	GLint status;
	glGetProgramiv (uiProgram, GL_LINK_STATUS, &status);
	if (status == GL_FALSE)
	{
		GLint infoLogLength;
		glGetProgramiv(uiProgram, GL_INFO_LOG_LENGTH, &infoLogLength);

		GLchar *strInfoLog = new GLchar[infoLogLength + 1];
		glGetProgramInfoLog(uiProgram, infoLogLength, NULL, strInfoLog);
		fprintf(stderr, "Linker failure: %s\n", strInfoLog);
		delete[] strInfoLog;
	}

	for(auto shader = shaderList.begin(); shader != shaderList.end(); shader++)
	{
		glDetachShader(uiProgram, *shader);
		glDeleteShader(*shader);
	}

	return uiProgram;
}

int main()
{
	//Initialise GLFW
	if(!glfwInit())
	{
		return -1;
	}

	//create a windowed mode window and it's OpenGL context
	GLFWwindow* window;
	window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
	if(!window)
	{
		glfwTerminate();
		return -1;
	}

	//make the window's context current
	glfwMakeContextCurrent(window);

	float points[] =
	{
		0.0f	,	0.5f	,	0.0f,
		0.5f	,	-0.5f	,	0.0f,
		-0.5f	,	-0.5f	,	1.0f,
		0.0f	,	0.5f	,	0.0f,
		-0.5f	,	0.5f	,	0.0f,
		0.5f	,	0.5f	,	1.0f,
		0.0f	,	0.5f	,	0.0f,
		0.5f	,	-0.5f	,	0.0f,
		-0.5f	,	-0.5f	,	1.0f,
		0.0f	,	0.5f	,	0.0f,
		-0.5f	,	0.5f	,	0.0f,
		0.5f	,	0.5f	,	1.0f,
	};
	float colours[] =
	{
		1.0f	,	0.0f	,	0.0f,
		0.0f	,	1.0f	,	0.0f,
		0.0f	,	0.0f	,	1.0f,
		0.0f	,	0.0f	,	1.0f,
		0.0f	,	1.0f	,	0.0f,
		1.0f	,	0.0f	,	0.0f,
		1.0f	,	0.0f	,	0.0f,
		0.0f	,	1.0f	,	0.0f,
		0.0f	,	0.0f	,	1.0f,
		0.0f	,	0.0f	,	1.0f,
		0.0f	,	1.0f	,	0.0f,
		1.0f	,	0.0f	,	0.0f
	};

	// start GLEW
	if (glewInit() != GLEW_OK)
	{
		// OpenGL didn't start-up! shutdown GLFW and return an error code
		glfwTerminate();
		return -1;
	};
	//………
	GLuint shaderProgram = CreateProgram("./shaders/simple.vert", "./shaders/simple.frag");
	glUseProgram(shaderProgram);

	GLuint MatrixID = glGetUniformLocation(shaderProgram, "MVP");

	glm::mat4 Projection = glm::perspective(35.0f, 4.0f / 3.0f, 0.1f, 100.0f);
	glm::mat4 View       = glm::lookAt(
	glm::vec3(4,2,2), // Camera location
	glm::vec3(0,0,0), // and looks at the origin
	glm::vec3(0,-1,0)  // Head is up (set to 0,-1,0 to look upside-down)
	);

	glm::mat4 myMatrix = glm::translate(glm::mat4(-2.f),glm::vec3(0.f));
	glm::mat4 Model = glm::mat4(1.f);
	Model= myMatrix * Model;
	glm::mat4 MVP = Projection * View * Model;

	glm::mat4 myMatrix2 = glm::translate(glm::mat4(2.f),glm::vec3(0.f));
	glm::mat4 Model2 = glm::mat4(1.f);
	Model2= myMatrix2 * Model2;
	glm::mat4 MVP2 = Projection * View * Model2;

	glm::mat4 myMatrix3 = glm::translate(glm::mat4(4.f),glm::vec3(0.f));
	glm::mat4 Model3 = glm::mat4(1.f);
	Model3= myMatrix3 * Model3;
	glm::mat4 MVP3 = Projection * View * Model3;

	glm::mat4 myMatrix4 = glm::translate(glm::mat4(8.f),glm::vec3(0.f));
	glm::mat4 Model4 = glm::mat4(1.f);
	Model4= myMatrix4 * Model4;
	glm::mat4 MVP4 = Projection * View * Model4;

	glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]);
	glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP2[0][0]);
	glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP3[0][0]);
	glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP4[0][0]);

	GLuint points_vbo = 0;
	glGenBuffers (1, &points_vbo);
	glBindBuffer (GL_ARRAY_BUFFER, points_vbo);
	glBufferData (GL_ARRAY_BUFFER, 18 * sizeof (float), points, GL_STATIC_DRAW);

	GLuint colours_vbo = 0;
	glGenBuffers (1, &colours_vbo);
	glBindBuffer (GL_ARRAY_BUFFER, colours_vbo);
	glBufferData (GL_ARRAY_BUFFER, 18 * sizeof (float), colours, GL_STATIC_DRAW);

	GLuint vao = 0;
	glGenVertexArrays (1, &vao);
	glBindVertexArray (vao);
	glBindBuffer (GL_ARRAY_BUFFER, points_vbo);
	glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
	glBindBuffer (GL_ARRAY_BUFFER, colours_vbo);
	glVertexAttribPointer (1, 3, GL_FLOAT, GL_FALSE, 0, NULL);

	glEnableVertexAttribArray (0);
	glEnableVertexAttribArray (1);


while (!glfwWindowShouldClose(window))
{
	//loop until the user closes the window
	while(!glfwWindowShouldClose(window))
	{
		glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		glUseProgram (shaderProgram);

		glBindVertexArray (vao);

		//draw code goes here
		glDrawArrays(GL_TRIANGLES,0,12*3);

		glfwSwapBuffers(window);

		//poll for and process events
		glfwPollEvents();

		if (glfwGetKey (window, GLFW_KEY_ESCAPE))
			glfwSetWindowShouldClose (window, 1);
	}

	glfwTerminate();
	return 0;
}
}