#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <fstream>

#include <GL\glew.h>
#include <GLFW\glfw3.h>

std::string LoadFileToString(const char* filepath) {
	std::string fileData;
	std::ifstream stream(filepath, std::ios::in);

	if (stream.is_open()) {
		std::string line = "";

		while (getline(stream, line)) {
			fileData += "\n" + line;
		}

		stream.close();
	}

	return fileData;
}

GLuint LoadShaders(const char* vertShaderPath, const char* fragShaderPath) {
	GLuint vertShader = glCreateShader(GL_VERTEX_SHADER);
	GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);

	std::string vertShaderSource = LoadFileToString(vertShaderPath);
	std::string fragShaderSource = LoadFileToString(fragShaderPath);

	const char* rawVertShaderSource = vertShaderSource.c_str();
	const char* rawFragShaderSource = fragShaderSource.c_str();

	glShaderSource(vertShader, 1, &rawVertShaderSource, NULL);
	glShaderSource(fragShader, 1, &rawFragShaderSource, NULL);

	glCompileShader(vertShader);
	glCompileShader(fragShader);

	GLuint program = glCreateProgram();
	glAttachShader(program, vertShader);
	glAttachShader(program, fragShader);
	glLinkProgram(program);

	return program;
}

int main(int argv, char** argc) {
	if (glfwInit() == false) { // If GLFW Isn't Working
		// Did Not Succeed
		fprintf(stderr, "GLFW failed to initialise.");
		return -1; // Returns Error
	}

	glfwWindowHint(GLFW_SAMPLES, 16); // Antialiasing
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // GLFW Version
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); // GLFW Version
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	GLFWwindow* window; // GLFW* window is a pointer to make the window. As below.
	window = glfwCreateWindow(800, 600, "My OpenGL", NULL, NULL); // Make The Window

	if (!window) {
		fprintf(stderr, "Window failed to create");
		glfwTerminate();
		return -1;
	}

	glfwMakeContextCurrent(window); // Show Window
	glewExperimental = true; // Allowes Us To Run

	if (glewInit() != GLEW_OK) { // If GLEW Isn't OK
		fprintf(stderr, "GLEW failed to initialise");
		glfwTerminate();
		return -1;
	}

	GLuint vaoID; // Open GL's ID's
	glGenVertexArrays(1, &vaoID); // Generate vertex arrays then sending it to the vaoID
	glBindVertexArray(vaoID); // Tells OpenGL that we're going to use this type of vertext array

	static const GLfloat verts[] = {
		// X, Y, Z
		 -1.0f, -1.0f, 0.0f,
		 1.0f, -1.0f, 0.0f,
		 0.0f,  1.0f, 0.0f
	};

	GLuint program = LoadShaders("shader.vertshader", "shader.fragshader");

	// Generate VBO
	GLuint vboID;
	glGenBuffers(1, &vboID);
	glBindBuffer(GL_ARRAY_BUFFER, vboID); // Current working buffer
	glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);

	glClearColor(0.0f, 0.0f, 1.0f, 1.0f);

	do {
		glClear(GL_COLOR_BUFFER_BIT);
		glEnableVertexAttribArray(0);
		glBindBuffer(GL_ARRAY_BUFFER, vboID);
		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);  // 3 is xyz

		glUseProgram(program);
		glDrawArrays(GL_TRIANGLES, 0, 3);

		glDisableVertexAttribArray(0);

		glfwSwapBuffers(window); // Buffers
		glfwPollEvents();
	} while (glfwWindowShouldClose(window) == false); // While Not Closed

	return 0;
}

/* Easier in C++ */