#include <assert.h>
#include <stddef.h>
#include <stdio.h>

#define GLFW_INCLUDE_NONE
#include <GLFW/glfw3.h>
#include <glad/glad.h>

void framebuffer_size_cb([[maybe_unused]] GLFWwindow *win, int width, int height) {
    glViewport(0, 0, width, height);
}

void process_input(GLFWwindow *win) {
    if (glfwGetKey(win, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
        glfwSetWindowShouldClose(win, 1);
    }
}

void error_cb([[maybe_unused]] int err, const char *desc) {
    fprintf(stderr, "Error: %s\n", desc);
}

const char *vertex_shader_src =
    "#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"
    "}";

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

int main() {
    if (!glfwInit()) {
        puts("Nay");
        return -1;
    }

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

    GLFWwindow *win = glfwCreateWindow(800, 600, "Nigerundayo Smokey", NULL, NULL);
    if (!win) {
        fprintf(stderr, "Failed to create the window\n");
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(win);
    glfwSetFramebufferSizeCallback(win, framebuffer_size_cb);
    glfwSetErrorCallback(error_cb);

    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
        fprintf(stderr, "Couldn't load opengl\n");
        glfwTerminate();
        return -1;
    }

    {
        int max_vertex_attr;
        glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &max_vertex_attr);
        printf("Max number of vertex attributes supported: %d\n", max_vertex_attr);

        printf("GL_VERSION = %s\n", glGetString(GL_VERSION));
        printf("GL_VENDOR = %s\n",  glGetString(GL_VENDOR));
        printf("GL_RENDERER = %s\n",  glGetString(GL_RENDERER));
    }

    int success;
    char logs[512];

    unsigned int vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    {
        glShaderSource(vertex_shader, 1, &vertex_shader_src, NULL);
        glCompileShader(vertex_shader);

        glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success);
        if (!success) {
            glGetShaderInfoLog(vertex_shader, sizeof(logs), NULL, logs);
            fprintf(stderr, "Vertex shader compilation failed: %s\n", logs);
        }
    }

    unsigned int fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    {
        glShaderSource(fragment_shader, 1, &fragment_shader_src, NULL);
        glCompileShader(fragment_shader);

        glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success);
        if (!success) {
            glGetShaderInfoLog(fragment_shader, sizeof(logs), NULL, logs);
            fprintf(stderr, "Fragment shader compilation failed: %s\n", logs);
        }
    }

    unsigned int shader_program = glCreateProgram();
    {
        glAttachShader(shader_program, vertex_shader);
        glAttachShader(shader_program, fragment_shader);
        glLinkProgram(shader_program);

        glGetProgramiv(shader_program, GL_LINK_STATUS, &success);
        if (!success) {
            glGetProgramInfoLog(shader_program, sizeof(logs), NULL, logs);
            fprintf(stderr, "Program linking failed: %s\n", logs);
        }

        glDeleteShader(vertex_shader);
        glDeleteShader(fragment_shader);
    }

    const float vertices[] = {
         0.5f,  0.5f, 0.0f,
         0.5f, -0.5f, 0.0f,
        -0.5f, -0.5f, 0.0f,
        -0.5f,  0.5f, 0.0f,
    };
    unsigned int indices[] = {
        0, 1, 3,
        1, 2, 3,
        0, 1, 2,
    };
    unsigned int VBO, VAO, EBO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    glGenBuffers(1, &EBO);

    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
    glEnableVertexAttribArray(0);

    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    // wireframe polygons
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

    // -- loop --
    while (!glfwWindowShouldClose(win)) {
        process_input(win);

        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        glUseProgram(shader_program);
        glBindVertexArray(VAO);
        //glDrawArrays(GL_TRIANGLES, 0, sizeof(vertices));
        glDrawElements(GL_TRIANGLES, sizeof(indices), GL_UNSIGNED_INT, 0);
        glBindVertexArray(0);

        glfwSwapBuffers(win);
        glfwPollEvents();
    }

    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteProgram(shader_program);

    glfwTerminate();
    return 0;
}

///////////////////////////////////////////////////////////////////////////////


//#include <stdio.h>
//
//#define GLFW_INCLUDE_NONE
//#include <GLFW/glfw3.h>
//#include <glad/glad.h>
//
//#include <stdio.h>
//
//int main( void ) {
//    if (!glfwInit())
//        return -1;
//
//    GLFWwindow *win = glfwCreateWindow(320, 130, "Window!", NULL, NULL);
//    glfwMakeContextCurrent(win);
//
//    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
//        printf("Couldn't load opengl\n");
//        glfwTerminate();
//        return -1;
//    }
//
//    glClearColor(0.25f, 0.5f, 0.75f, 1.0f);
//
//    while (!glfwWindowShouldClose(win)) {
//        glfwPollEvents();
//
//        glClear(GL_COLOR_BUFFER_BIT);
//
//        glfwSwapBuffers(win);
//    }
//
//    glfwTerminate();
//    return 0;
//}

//int main(int argc, char *argv[]) {
//    printf("Nigerundayo Smockey\n");
//    return 0;
//}