#include <iostream>
#include <fstream>
#include <iterator>
#include <array>
#include <stdlib.h>
#include <string>
#include <vector>
#include <sstream>
#include <SDL.h>
#include <gl/glew.h>
#include <SDL_opengl.h>

SDL_Window *mainwindow = { 0 };
SDL_GLContext maincontext = { 0 };
SDL_Event mainevent;

class SDL_Engine {
	public:
		int SDL_Start() {
			SDL_Init(SDL_INIT_EVERYTHING);
			return 1;
		}

		int Setup_GL_Window_DEFAULT(
			int x, int y, int w, int h, const char *title)
		{
			mainwindow = SDL_CreateWindow("C++ GL Engine", 100, 100, 640, 480,
				SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);

			maincontext = SDL_GL_CreateContext(mainwindow);
			SDL_GL_MakeCurrent(mainwindow, maincontext);

			GLenum err = glewInit();
			if (GLEW_OK != err)
			{
				/* Problem: glewInit failed, something is seriously wrong. */
				printf("Error: %s\n", glewGetErrorString(err));
			}

			printf("Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));

			return 2;
		}
};



class OGL_Engine {
	public :
		GLuint LoadShader(const char *vertshaderfilename, const char *fragshaderfilename, GLuint ShaderProgram) {

			//VERTEX SHADER SOURCE AND COMPILE CODE
			std::ifstream vertfile(vertshaderfilename);

			vertfile.seekg(0, vertfile.end);
			int vertlength = vertfile.tellg();
			vertfile.seekg(0, vertfile.beg);

			char *tempvertbuffer = new char[vertlength];

			std::string tempvertstring;

			std::cout << vertlength << std::endl;

			while (vertfile.getline(tempvertbuffer, vertlength))
			{
				tempvertstring += tempvertbuffer;
				tempvertstring += '\n';
			}

			vertfile.close();

			GLuint vertexshader = glCreateShader(GL_VERTEX_SHADER);

			const char *vertcbuffer = new char[vertlength];

			vertcbuffer = tempvertstring.c_str();

			std::cout << vertcbuffer << std::endl;
			glShaderSource(vertexshader, 1, &vertcbuffer, &vertlength);

			glCompileShader(vertexshader);

			GLint vertsuccess = 0;
			glGetShaderiv(vertexshader, GL_COMPILE_STATUS, &vertsuccess);
			std::cout << vertsuccess << std::endl;
			if(vertsuccess == GL_FALSE)
			{

				GLint vertmaxlength = 0;
				glGetShaderiv(vertexshader, GL_INFO_LOG_LENGTH, &vertmaxlength);

				char *vertinfolog = new char[vertmaxlength];

				glGetShaderInfoLog(vertexshader, vertmaxlength, &vertmaxlength, vertinfolog);


				std::cout << vertinfolog << std::endl;
			}


			//FRAGMENT SHADER SOURCE AND COMPILE CODE
			std::ifstream fragfile(fragshaderfilename);

			fragfile.seekg(0, fragfile.end);
			int fraglength = fragfile.tellg();
			fragfile.seekg(0, fragfile.beg);

			char *tempfragbuffer = new char[fraglength];

			std::string tempfragstring;

			std::cout << fraglength << std::endl;

			while (fragfile.getline(tempfragbuffer, fraglength))
			{
				tempfragstring += tempfragbuffer;
				tempfragstring += '\n';
			}

			fragfile.close();

			GLuint fragmentshader = glCreateShader(GL_FRAGMENT_SHADER);

			const char *fragcbuffer = new char[fraglength];

			fragcbuffer = tempfragstring.c_str();

			std::cout << fragcbuffer << std::endl;
			glShaderSource(fragmentshader, 1, &fragcbuffer, &fraglength);

			glCompileShader(fragmentshader);

			GLint fragsuccess = 0;
			glGetShaderiv(fragmentshader, GL_COMPILE_STATUS, &fragsuccess);
			std::cout << fragsuccess << std::endl;
			if (fragsuccess == GL_FALSE)
			{

				GLint fragmaxlength = 0;
				glGetShaderiv(fragmentshader, GL_INFO_LOG_LENGTH, &fragmaxlength);

				char *fraginfolog = new char[fragmaxlength];

				glGetShaderInfoLog(fragmentshader, fragmaxlength, &fragmaxlength, fraginfolog);


				std::cout << fraginfolog << std::endl;
			}

			ShaderProgram = glCreateProgram();

			glAttachShader(ShaderProgram, vertexshader);
			glAttachShader(ShaderProgram, fragmentshader);


			glLinkProgram(ShaderProgram);
			GLint shaderprogramlinking = 0;
			glGetProgramiv(ShaderProgram, GL_LINK_STATUS, &shaderprogramlinking);

			if (shaderprogramlinking == GL_FALSE)
			{
				std::cout << "not fucking " << std::endl;
			}
			GLint shaderloglength = 0;
			glGetProgramiv(ShaderProgram, GL_INFO_LOG_LENGTH, &shaderloglength);
			char *shaderInfoLog = new char[shaderloglength];
			glGetProgramInfoLog(ShaderProgram, shaderloglength, &shaderloglength, shaderInfoLog);

			std::cout << "cunt \n" << shaderInfoLog << std::endl;

			return ShaderProgram;

		}

		//GLint GetUniform(GLuint program, const GLchar * name, GLint location,
		//	GLsizei count, const GLfloat *value)
		//{

		//	location = glGetUniformLocation(program , name);
		//	glUniformMatrix4fv(location, 1, GL_TRUE, value);

		//	return 1;
		//}


};
int main(int argc, char *argv[])
{
	SDL_Engine SDL_engine;

	SDL_engine.SDL_Start();

	SDL_engine.Setup_GL_Window_DEFAULT( 100, 100, 640, 480,
	"C++ GL Engine");

	OGL_Engine OGL_engine;



	//potential problem drawarray uses it too
	GLuint vertexarray = 0;

	//OGL_engine.GenerateAndBindVertexArray(0, vertexarray, 0);

	GLuint vertbuffer = 0;

	std::vector<GLfloat> vertbufferdata, vertbufferdata2;

	GLfloat vertdata[] = {
		+0.0f, +0.0f, +0.0f,
		+0.5f, +0.5, +0.0f,
		-0.5f,  +0.5f, +0.0f,

		+0.0f, +0.0f, +0.0f,
		-0.5f, -0.5, +0.0f,
		+0.5f,  -0.5f, +0.0f
	};
	//possible problem with vertdata
	vertbufferdata.insert(vertbufferdata.end(), &vertdata[0], &vertdata[18]);
	for (int i = 0; i < vertbufferdata.size(); i++)
	std::cout << ' ' << vertbufferdata[i] << std::endl;



	GLenum errortag = 0;

	//OGL_engine.SetBufferData(1, vertbuffer, vertbufferdata, errortag);

	GLuint VAO = 0;
	//glGenVertexArrays(1, &VAO);
	std::cout << "NUM: " << VAO << std::endl;
	//glBindVertexArray(VAO);

	GLuint ShaderPrograms = 0;
	ShaderPrograms = OGL_engine.LoadShader("shader/vertshader.vert", "shader/fragshader.frag", ShaderPrograms);

	GLuint VBO = 0, VBO2;

	glGenBuffers(1, &VBO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);

	glBufferData(GL_ARRAY_BUFFER, vertbufferdata.size() * sizeof(GLfloat), vertbufferdata.data(), GL_STATIC_DRAW);


	glEnableVertexAttribArray(0);

	glBindBuffer(GL_ARRAY_BUFFER, VBO);

	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);


	//GLint GetUniform(GLuint program, const GLchar * name, GLint location,
	//	GLsizei count, const GLfloat *value)
	//{

	//	GLint location = glGetUniformLocation(program, name);
	//	glUniformMatrix4fv(location, 1, GL_FALSE, value);
	//}
	GLuint univar = 0;

	/*std::vector<GLfloat> modelviewmatrixvec;
	modelviewmatrixvec.insert(modelviewmatrixvec.end(), &modelviewmatrix[0], &modelviewmatrix[15]);

	for (int i = 0; i < modelviewmatrixvec.size(); i++)
		std::cout << ' ' << modelviewmatrixvec[i] << std::endl;*/

	//OGL_engine.GetUniform(ShaderPrograms, "modelview", univar,
	//	1, &modelviewmatrix[0]);


	const GLfloat modelviewmatrix[] = {
		1.0f , 0.0f , 0.0f , 0.0f,
		0.0f, 1.0f, 0.0f , 0.0f ,
		0.0f, 0.0f, 1.0f, 0.0f,
		0.0f, 0.0f, 0.0f, 1.0f
	};

	GLint locationID = glGetUniformLocation(ShaderPrograms, "modelviewMatrix");

	std::cout << "location->" <<locationID << std::endl;
	glUniformMatrix4fv(locationID, 1, GL_FALSE, modelviewmatrix);

	GLenum error;

	error = glGetError();

	if (error != GL_NO_ERROR)
	{
		std::cout << "not working" << std::endl;
	}

	if (error == GL_INVALID_OPERATION)
	{
		std::cout << "FUCKING INVALID OPERATION" << std::endl;
	}
	if (error == GL_NO_ERROR)
	{
		std::cout << "No Fucking Error! -> CODE CHECKING <-" << std::endl;
	}

	if (error == GL_INVALID_VALUE)
	{
		std::cout << "NO FUCKING VALUE" << std::endl;
	}

	if (error == GL_OUT_OF_MEMORY)
	{
		std::cout << "NO FUCKING MEMORY" << std::endl;
	}

	if (error == GL_STACK_OVERFLOW)
	{
		std::cout << "NO FUCKING OVERFLOW" << std::endl;
	}


	if (error == GL_INVALID_FRAMEBUFFER_OPERATION)
	{
		std::cout << "invalid framebuffer <-" << std::endl;
	}

	if (error == GL_OUT_OF_MEMORY)
	{
		std::cout << "Out of Memory" << std::endl;
	}


	//OGL_engine.SetVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
		//3 * sizeof(GLfloat), (GLvoid*)0);

	//OGL_engine.BindVertexArray(vertexarray);

	glClearColor(0, 0, 0, 1.0);
	bool running = true;
	while (running == true) {
		while (SDL_PollEvent(&mainevent)) {
			switch (mainevent.type){
					case SDL_QUIT:
						SDL_GL_DeleteContext(maincontext);
						SDL_Quit();
						return 0;
			}

		}
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		//OGL_engine.DrawArray(GL_TRIANGLES, vertbufferdata[0], vertbufferdata.size(), vertexarray);
		glUseProgram(ShaderPrograms);
		glDrawArrays(GL_TRIANGLES, vertbufferdata[0], vertbufferdata.size());
		SDL_GL_SwapWindow(mainwindow);
	}
	return 0;
}

//int BindVertexArray(GLuint array)
//{
//	glBindVertexArray(array);
//	return 1;
//}

//int GenerateAndBindVertexArray(GLsizei num, GLuint array, int van)
//{
//	glGenVertexArrays(num, &array);
//	std::cout << "num " << num << std::endl;
//	glBindVertexArray(array);
//
//	return 2;
//}

//int BindVertexBuffer(GLuint vbo)
//{
//	glBindBuffer(GL_ARRAY_BUFFER, vbo);
//	return 3;
//}

//int GenerateAndBindVertexBufferObject(GLsizei num, GLuint vbo)
//{
//	glGenBuffers(num, &vbo);
//	std::cout << "BUFFERNAME -> " << vbo << std::endl;
//	glBindBuffer(GL_ARRAY_BUFFER, vbo);

//	return 4;
//}

//int SetBufferData(GLsizei num, GLuint vbo, std::vector<float> bufferdata, GLenum error)
////MEMORY STORAGE OF DATA
//{

//	//CHECK * sizeof(float) or size()
//	glBufferData(GL_ARRAY_BUFFER, bufferdata.size() * sizeof(float), bufferdata.data(), GL_STATIC_DRAW);

//	glBindBuffer(GL_ARRAY_BUFFER, vbo);

//	error = glGetError();
//	if (error == GL_NO_ERROR)
//	{
//		std::cout << "No Fucking Error! -> CODE CHECKING <-" << std::endl;
//	}

//	if (error == GL_INVALID_VALUE)
//	{
//		std::cout << "NO FUCKING VALUE" << std::endl;
//	}

//	if (error == GL_OUT_OF_MEMORY)
//	{
//		std::cout << "NO FUCKING MEMORY" << std::endl;
//	}

//	if (error == GL_STACK_OVERFLOW)
//	{
//		std::cout << "NO FUCKING OVERFLOW" << std::endl;
//	}

//	return 5;
//}

//int SetVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized,
//	GLsizei stride, const GLvoid *pointer) {
//	//potential problem with pointer ->
//	glVertexAttribPointer(index, size, type, normalized, stride, &pointer);
//	glEnableVertexAttribArray(index);

//	return 6;
//}


//int DrawArray(GLenum amode, GLint afirst, GLsizei acount, GLuint array)
//{
//	glBindVertexArray(array);
//	glDrawArrays(amode, afirst, acount);


//	return 7;
//}