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

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

#include <glm/vec3.hpp>
#include <glm/mat4x4.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>


GLuint rendering_program;
GLuint vertex_array_object;
GLuint buffer;
GLuint colorbuffer;

GLint mv_location;
GLint proj_location;

float aspect;
glm::mat4 mv_matrix;
glm::mat4 proj_matrix;


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);

    aspect = (float) width / (float) height;
    proj_matrix = glm::perspective(glm::radians(50.0f), aspect, 0.1f, 1000.0f);
}

GLuint compile_shaders(void) {
    GLuint vertex_shader;
    GLuint fragment_shader;
    GLuint program;

    static const GLchar * vertex_shader_source[] = {
        "#version 330 core \n"
        "in vec4 position;"
        "in vec4 vertexColor;"
        "out vec4 color1;"

        "uniform mat4 mv_matrix;"
        "uniform mat4 proj_matrix;"

        "void main(void) {"
        "    gl_Position = proj_matrix * mv_matrix * (position + gl_InstanceID + vec4(1,0,0,0));"
        "color1=vertexColor;"
        "}"
    };

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

        "out vec4 color;"

        "void main(void) {"
        "    color = color1;"
        "}"
    };GLuint colorbuffer;


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

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

    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);

    static const GLfloat vertex_positions[] = {
        -0.25f,  0.25f, -0.25f,
        -0.25f, -0.25f, -0.25f,
         0.25f, -0.25f, -0.25f,

         0.25f, -0.25f, -0.25f,
         0.25f,  0.25f, -0.25f,
        -0.25f,  0.25f, -0.25f,

         0.25f, -0.25f, -0.25f,
         0.25f, -0.25f,  0.25f,
         0.25f,  0.25f, -0.25f,

         0.25f, -0.25f,  0.25f,
         0.25f,  0.25f,  0.25f,
         0.25f,  0.25f, -0.25f,

         0.25f, -0.25f,  0.25f,
        -0.25f, -0.25f,  0.25f,
         0.25f,  0.25f,  0.25f,

        -0.25f, -0.25f,  0.25f,
        -0.25f,  0.25f,  0.25f,
         0.25f,  0.25f,  0.25f,

        -0.25f, -0.25f,  0.25f,
        -0.25f, -0.25f, -0.25f,
        -0.25f,  0.25f,  0.25f,

        -0.25f, -0.25f, -0.25f,
        -0.25f,  0.25f, -0.25f,
        -0.25f,  0.25f,  0.25f,

        -0.25f, -0.25f,  0.25f,
         0.25f, -0.25f,  0.25f,
         0.25f, -0.25f, -0.25f,

         0.25f, -0.25f, -0.25f,
        -0.25f, -0.25f, -0.25f,
        -0.25f, -0.25f,  0.25f,

        -0.25f,  0.25f, -0.25f,
         0.25f,  0.25f, -0.25f,
         0.25f,  0.25f,  0.25f,

         0.25f,  0.25f,  0.25f,
        -0.25f,  0.25f,  0.25f,
        -0.25f,  0.25f, -0.25f
    };


    glGenBuffers(1, &buffer);
    glBindBuffer(GL_ARRAY_BUFFER, buffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_positions), vertex_positions, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
    glEnableVertexAttribArray(0);


    static const GLfloat g_color_buffer_data[] = {
        0.583f,  0.771f,  0.014f, 0.014f,
        0.609f,  0.115f,  0.436f, 0.014f,
        0.327f,  0.483f,  0.844f, 0.014f,
        0.822f,  0.569f,  0.201f, 0.014f,
        0.435f,  0.602f,  0.223f, 0.014f,
        0.310f,  0.747f,  0.185f, 0.014f,
        0.597f,  0.770f,  0.761f, 0.014f,
        0.559f,  0.436f,  0.730f, 0.014f,
        0.359f,  0.583f,  0.152f,0.014f,
        0.483f,  0.596f,  0.789f,0.014f,
        0.559f,  0.861f,  0.639f,0.014f,
        0.195f,  0.548f,  0.859f,0.014f,
        0.014f,  0.184f,  0.576f,0.0140f,
        0.771f,  0.328f,  0.970f,0.014f,
        0.406f,  0.615f,  0.116f,0.014f,
        0.676f,  0.977f,  0.133f,0.014f,
        0.971f,  0.572f,  0.833f,0.014f,
        0.140f,  0.616f,  0.489f,0.014f,
        0.997f,  0.513f,  0.064f,0.014f,
        0.945f,  0.719f,  0.592f,0.014f,
        0.543f,  0.021f,  0.978f,0.014f,
        0.279f,  0.317f,  0.505f,0.014f,
        0.167f,  0.620f,  0.077f,0.014f,
        0.347f,  0.857f,  0.137f,0.014f,
        0.055f,  0.953f,  0.042f,0.014f,
        0.714f,  0.505f,  0.345f,0.014f,
        0.783f,  0.290f,  0.734f,0.014f,
        0.722f,  0.645f,  0.174f,0.014f,
        0.302f,  0.455f,  0.848f,0.014f,
        0.225f,  0.587f,  0.040f,0.014f,
        0.517f,  0.713f,  0.338f,0.014f,
        0.053f,  0.959f,  0.120f,0.014f,
        0.393f,  0.621f,  0.362f,0.014f,
        0.673f,  0.211f,  0.457f,0.014f,
        0.820f,  0.883f,  0.371f,0.014f,
        0.982f,  0.099f,  0.879f,0.014f,
    };

    glGenBuffers(1, &colorbuffer);
    glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(g_color_buffer_data), g_color_buffer_data, GL_STATIC_DRAW);
    glEnableVertexAttribArray(1);

    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL);

    glEnable(GL_CULL_FACE);
    glFrontFace(GL_CW);
}

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

void render(double currentTime) {
    float f = (float) currentTime * (float) M_PI * 0.1f;
    glm::mat4 I = glm::mat4(1.0f);
    mv_matrix = (
        glm::translate(I, glm::vec3((float) sin(f)*0.5, (float) cos(f)*0.5, -2.0f))
    );

    mv_matrix = glm::rotate(mv_matrix, 4*f, glm::vec3(0.5f, 0.5f, 1.0f));

    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);

    mv_location = glGetUniformLocation(rendering_program, "mv_matrix");
    proj_location = glGetUniformLocation(rendering_program, "proj_matrix");
    glUniformMatrix4fv(mv_location, 1, GL_FALSE, glm::value_ptr(mv_matrix));
    glUniformMatrix4fv(proj_location, 1, GL_FALSE, glm::value_ptr(proj_matrix));

    glDrawArraysInstanced(GL_TRIANGLES, 0, 36, 20);

    // for(int i = 0; i < 10; i++) {
    //      mv_matrix = (
    //     glm::translate(I, glm::vec3((float) cos(f)*i/10, (float) sin(f)*i/10, -2.0f))
    // );

    // mv_matrix = glm::rotate(mv_matrix, 4*f, glm::vec3(0.5f, 0.5f, 1.0f));
    // glUniformMatrix4fv(mv_location, 1, GL_FALSE, glm::value_ptr(mv_matrix));
    // glUniformMatrix4fv(proj_location, 1, GL_FALSE, glm::value_ptr(proj_matrix));
    // glDrawArrays(GL_TRIANGLES, 0, 36);
    // }

}

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);
    proj_matrix = glm::perspective(glm::radians(50.0f), 800/600.0f, 0.1f, 1000.0f);

    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;
}