// https://learnopengl.com/Getting-started/OpenGL

#include <iostream>

#include <GL/glew.h>
#include <GL/glut.h>

#include "TutorialConfig.h"


float x=-0.5;
GLuint shaderProgram_glob;
GLuint shaderProgram1_glob;
GLuint VAO_glob;
GLuint VAO1_glob;

void renderScene(void) {

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

        glUseProgram(shaderProgram1_glob);
        glBindVertexArray(VAO1_glob);
	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

        glUseProgram(shaderProgram_glob);
        glBindVertexArray(VAO_glob);
        glDrawArrays(GL_TRIANGLES, 0, 3);


	/* glBegin(GL_TRIANGLES) */
	/* 	glVertex3f(-0.5,x,0.0); */
	/* 	glVertex3f(0.5,0.0,0.0); */
	/* 	glVertex3f(0.0,0.5,0.0); */
	/* glEnd(); */

        x+=0.1f;
        if(x>0)x=-0.5;

//	glutWarpPointer(100,100);
        glutSwapBuffers();
}

void idle(void) {
    glutPostRedisplay();
}

void processNormalKeysUp(unsigned char key, int x, int y) {
        std::cout << "up" << std::endl;
        if (key == 27) exit(0);
}
void processNormalKeysDown(unsigned char key, int x, int y) {
        std::cout << "down" << std::endl;
        if (key == 27) exit(0);
}
void processSpecKeysUp(int key, int x, int y) {
        std::cout << "spec up" << std::endl;
}
void processSpecKeysDown(int key, int x, int y) {
        std::cout << "spec down" << std::endl;
}

void exiting(){
        std::cout << "game over" << std::endl;
}

void reshape(int w, int h){
        std::cout << "reshape" << std::endl;
	glViewport (0,0,w,h);
}

void tim (int v)
{
        std::cout << "tim" << std::endl;
}
int main(int argc, char **argv) {

	atexit(exiting);

	// init GLUT and create Window
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowPosition(100,100);
	glutInitWindowSize(320,320);
	glutCreateWindow("Lighthouse3D - GLUT Tutorial");
	glutIdleFunc(idle);
	glutDisplayFunc(renderScene);

	glutReshapeFunc(reshape);

	glutSetKeyRepeat(GLUT_KEY_REPEAT_OFF);
	glutKeyboardFunc(processNormalKeysDown);
        glutKeyboardUpFunc(processNormalKeysUp);

	glutSpecialFunc(processSpecKeysDown);
	glutSpecialUpFunc(processSpecKeysUp);

	glutSetCursor(GLUT_CURSOR_NONE);
	//glutMouseFunc()
	//glutMotionFunc()
	//glutPassiveMotionFunc()

	//glutEntryFunc();
	//glutVisibilityFunc();

        glutTimerFunc(3000,tim,1);
        glutTimerFunc(6000,tim,1);



        // call here - not to soon not too late :P 
        GLenum err = glewInit();
        if (err != GLEW_OK){
            std::cout << "glew not ok" << std::endl;
              exit(1); // or handle the error in a nicer way
        }
        if (!GLEW_VERSION_2_1){
                     // check that the machine supports the 2.1 API.
            std::cout << "glew version does not support 2.1" << std::endl;
              exit(1); // or handle the error in a nicer way
        }

        int  success;
        char infoLog[512];

        const char *vertexShaderSource = "#version 330 core\n"
                "layout (location = 0) in vec3 aPos;\n"
                    "void main()\n"
                        "{\n"
                            "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
                                "}\0";
        const char *fragmentShaderSource = "#version 330 core\n"
            "out vec4 FragColor;  void main()   {           FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);      } \0";

        const char *fragmentShader1Source = "#version 330 core\n"
            "out vec4 FragColor;  void main()   {           FragColor = vec4(1.0f, 0.0f, 0.0f, 1.0f);      } \0";

        GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
        glCompileShader(vertexShader);

        glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
        if(!success)
        {
                glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
                    std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
        }

        GLuint fragmentShader;
        fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
        glCompileShader(fragmentShader);

        glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
        if(!success)
        {
                glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
                    std::cout << "ERROR::SHADER::FRAG::COMPILATION_FAILED\n" << infoLog << std::endl;
        }

        GLuint fragmentShader1;
        fragmentShader1 = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fragmentShader1, 1, &fragmentShader1Source, NULL);
        glCompileShader(fragmentShader1);

        glGetShaderiv(fragmentShader1, GL_COMPILE_STATUS, &success);
        if(!success)
        {
                glGetShaderInfoLog(fragmentShader1, 512, NULL, infoLog);
                    std::cout << "ERROR::SHADER::FRAG::COMPILATION_FAILED\n" << infoLog << std::endl;
        }



        GLuint shaderProgram = glCreateProgram();
        shaderProgram_glob = shaderProgram;
        glAttachShader(shaderProgram, vertexShader);
        glAttachShader(shaderProgram, fragmentShader);
        glLinkProgram(shaderProgram);

        glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
        if(!success) {
                glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
                    std::cout << "ERROR::SHADER::PROG::LINKING_FAILED\n" << infoLog << std::endl;
        }

        GLuint shaderProgram1 = glCreateProgram();
        shaderProgram1_glob = shaderProgram1;
        glAttachShader(shaderProgram1, vertexShader);
        glAttachShader(shaderProgram1, fragmentShader1);
        glLinkProgram(shaderProgram1);

        glGetProgramiv(shaderProgram1, GL_LINK_STATUS, &success);
        if(!success) {
                glGetProgramInfoLog(shaderProgram1, 512, NULL, infoLog);
                    std::cout << "ERROR::SHADER::PROG::LINKING_FAILED\n" << infoLog << std::endl;
        }

        glDeleteShader(vertexShader);
        glDeleteShader(fragmentShader);  
        glDeleteShader(fragmentShader1);  

        float vertices[] = {
            -0.5f, -0.5f, 0.0f,
            0.5f, -0.5f, 0.0f,
            0.0f,  0.5f, 0.0f
        };

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

        GLuint VAO;
        glGenVertexArrays(1, &VAO);  
        VAO_glob=VAO;
        glBindVertexArray(VAO);
        glBindBuffer(GL_ARRAY_BUFFER, VBO);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
        glEnableVertexAttribArray(0);  

	float vertices1[] = {
	    0.5f,  0.5f, 0.0f,  // top right
	    0.5f, -0.5f, 0.0f,  // bottom right
	    -0.5f, -0.5f, 0.0f,  // bottom left
	    -0.5f,  0.5f, 0.0f   // top left 
	};

        GLuint VBO1;
        glGenBuffers(1,&VBO1);
        glBindBuffer(GL_ARRAY_BUFFER, VBO1);  
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices1), vertices1, GL_STATIC_DRAW);

        GLuint VAO1;
        glGenVertexArrays(1, &VAO1);  
        VAO1_glob=VAO1;
        glBindVertexArray(VAO1);
        glBindBuffer(GL_ARRAY_BUFFER, VBO1);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
        glEnableVertexAttribArray(0);  

	unsigned int indices1[] = {  // note that we start from 0!
	    0, 1, 3,   // first triangle
	    1, 2, 3    // second triangle
	};  

	GLuint EBO;
	glGenBuffers(1, &EBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices1), indices1, GL_STATIC_DRAW); 

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);




        //

        std::cout << glGetString(GL_VERSION) << std::endl;

	// register callbacks

	// enter GLUT event processing cycle
	glutMainLoop();
	
	return 1;
}


/* void setShaders() { */
 
/*     GLuint v, g, f; */
/*     char *vs,*gs, *fs; */
 
/*     // Create shader handlers */
/*     v = glCreateShader(GL_VERTEX_SHADER); */
/*     g = glCreateShader(GL_GEOMETRY_SHADER); */
/*     f = glCreateShader(GL_FRAGMENT_SHADER); */ 
 
/*     // Read source code from files */
/*     vs = textFileRead("example.vert"); */
/*     gs = textFileRead("example.geom"); */
/*     fs = textFileRead("example.frag"); */
 
/*     const char * vv = vs; */
/*     const char * gg = gs; */
/*     const char * ff = fs; */
 
/*     // Set shader source */
/*     glShaderSource(v, 1, &vv,NULL); */
/*     glShaderSource(g, 1, &gg,NULL); */
/*     glShaderSource(f, 1, &ff,NULL); */
 
/*     free(vs);free(gs);free(fs); */
 
/*     // Compile all shaders */
/*     glCompileShader(v); */
/*     glCompileShader(g); */
/*     glCompileShader(f); */
 
/*     // Create the program */
/*     p = glCreateProgram(); */
 
/*     // Attach shaders to program */
/*     glAttachShader(p,v); */
/*     glAttachShader(p,g); */
/*     glAttachShader(p,f); */
 
/*     // Link and set program to use */
/*     glLinkProgram(p); */
/*     glUseProgram(p); */
/* } */

/* void main(int argc, char **argv) { */

/*     glutInit(&argc, argv); */
/*     setShaders(); */
/*     initGL(); */
/*     glutMainLoop(); */

/* } */