#include <stdio.h>
#include <math.h>

#include <GL/gl3w.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <string>

using namespace std;
GLuint rendering_program;
GLuint vertex_array_object;

void error_callback(int error, const char* description) {
    fprintf(stderr, "Error: %s\n", description);
}

static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
        glfwSetWindowShouldClose(window, GLFW_TRUE);
}

static void resize_callback(GLFWwindow* window, int width, int height) {
    glViewport(0, 0, width, height);
}

GLuint compile_shaders(void) {
    GLuint vertex_shader;
    GLuint fragment_shader;
    GLuint program;
    GLint testval;
    GLint abort = 0;
    const std::string vertex_source =
    #include "vertex.vs"
    ;
    const char *c_str = vertex_source.c_str();

    static const GLchar * fragment_shader_source[] = {
        "#version 330 core \n"

        "out vec4 color;"

        "void main(void) {"
        "    color = vec4(0.0, 0.8, 1.0, 1.0);"
        "}"
    };

    vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertex_shader, 1, &c_str, NULL);
    glCompileShader(vertex_shader);

    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragment_shader, 1, fragment_shader_source, NULL);
    glCompileShader(fragment_shader);

    glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &testval);
        if(testval == GL_FALSE)
        {
            abort = 1;
            char infolog[1024];
            glGetShaderInfoLog(vertex_shader,1024,NULL,infolog);
            cout << "The vertex shader failed to compile with the error:" << endl << infolog << endl;
        }

 glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &testval);
        if(testval == GL_FALSE)
        {
            abort = 1;
            char infolog[1024];
            glGetShaderInfoLog(fragment_shader,1024,NULL,infolog);
            cout << "The fragment shader failed to compile with the error:" << endl << infolog << endl;
        }

        glGetProgramiv(program, GL_LINK_STATUS, &testval);
        if(testval == GL_FALSE)
        {
            abort = 1;
            char infolog[1024];
            glGetProgramInfoLog(program,1024,NULL,infolog);
            cout << "The program failed to compile with the error:" << endl << infolog << endl;
        }
        if(abort)
        {
            cout << "errors occured, cannot continue, aborting." << endl;
            exit(-1);
        }
    program = glCreateProgram();
    glAttachShader(program, vertex_shader);
    glAttachShader(program, fragment_shader);
    glLinkProgram(program);

    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);

    return program;
}

void startup() {
    rendering_program = compile_shaders();
    glCreateVertexArrays(1, &vertex_array_object);
    glBindVertexArray(vertex_array_object);
}

void shutdown() {
    glDeleteVertexArrays(1, &vertex_array_object);
    glDeleteProgram(rendering_program);
}

void render(double currentTime) {
    const GLfloat color[] = {
        (float) sin(currentTime) * 0.5f + 0.5f,
        (float) cos(currentTime) * 0.5f + 0.5f,
        0.0f,
        1.0f
    };
    glClearBufferfv(GL_COLOR, 0, color);

    glUseProgram(rendering_program);
    glDrawArrays(GL_TRIANGLES, 0, 3);
}

int main(void) {
    GLFWwindow* window;

    glfwSetErrorCallback(error_callback);

    if(! glfwInit())
        return -1;

    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);

    window = glfwCreateWindow(800, 600, "Hello World", NULL, NULL);
    if(! window) {
        glfwTerminate();
        return -1;
    }

    glfwMakeContextCurrent(window);
    if(gl3wInit()) {
        fprintf(stderr, "failed to initialize OpenGL\n");
        return -1;
    }
    if(! gl3wIsSupported(3, 3)) {
        fprintf(stderr, "OpenGL 3.3 not supported\n");
        return -1;
    }
    printf("OpenGL %s, GLSL %s\n", glGetString(GL_VERSION),
           glGetString(GL_SHADING_LANGUAGE_VERSION));

    glfwSetKeyCallback(window, key_callback);
    glfwSetWindowSizeCallback(window, resize_callback);
    glfwSwapInterval(1);

    startup();

    while(!glfwWindowShouldClose(window)){
        render(glfwGetTime());

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    shutdown();

    glfwDestroyWindow(window);
    glfwTerminate();
    return 0;
}