#include <cx.h>

static int
cx_glrender(GLFWwindow *window, GLuint programID,
            ModelRegistry *mr) {

    GLuint vertexbuffer;
    GLuint colorbuffer;
    // Buffer for render data
    GLfloat *render_buffer;
    // Clear the screen.
    glClear(GL_COLOR_BUFFER_BIT);

    // Use our shader
    glUseProgram(programID);

    // Bind the render buffer to OpenGL
    glGenBuffers(1, &vertexbuffer);
    glGenBuffers(1, &colorbuffer);

    for (int i = 0; i < mr->model_count; i++) {

        render_buffer = model_applyTransformations(mr->models[i]);

        glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
        glBufferData(GL_ARRAY_BUFFER, mr->models[i]->bufsize*4*sizeof(GLfloat),
                     render_buffer, GL_STATIC_DRAW);

        // 1rst attribute buffer : vertices
        glEnableVertexAttribArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
        glVertexAttribPointer(
            0,                  // attribute 0 in the pipeline
            4,                  // size
            GL_FLOAT,           // type
            GL_FALSE,           // normalized?
            0,                  // stride
            NULL                // array buffer offset
        );

        glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);
        glBufferData(GL_ARRAY_BUFFER, mr->models[i]->bufsize*3*sizeof(GLfloat),
                     mr->models[i]->colors, GL_STATIC_DRAW);

        // 1rst attribute buffer : vertices
        glEnableVertexAttribArray(2);
        glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);
        glVertexAttribPointer(
            2,                  // attribute 0 in the pipeline
            3,                  // size
            GL_FLOAT,           // type
            GL_FALSE,           // normalized?
            0,                  // stride
            NULL                // array buffer offset
        );

        // Draw!
        glDrawArrays(GL_TRIANGLES, 0, mr->models[i]->bufsize); // 3 indices starting at 0 -> 1 triangle

        glDisableVertexAttribArray(0);
        glDisableVertexAttribArray(2);
        free(render_buffer);
    }

    // Swap buffers
    glfwSwapBuffers(window);
    glfwPollEvents();

    return 0;
}

static inline int
cx_loadShaders(GLuint *VertexArrayID, GLuint *programID) {
    glGenVertexArrays(1, VertexArrayID);
    glBindVertexArray(*VertexArrayID);

    // Create and compile our GLSL program from the shaders
    if (LoadShaders(programID,
                    "../shaders/SimpleVertexShader.vertexshader",
                    "../shaders/SimpleFragmentShader.fragmentshader")) {
        fprintf(stderr, "Could not load shaders.\n");
        return -1;
    }
    return 0;
}

int
cx_glinit(GLFWwindow **window) {
    // Initialise GLFW
    if(!glfwInit()) {
        fprintf(stderr, "Failed to initialize GLFW\n");
        return -1;
    }

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

    // To make MacOS happy; should not be needed
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

    // Open a window and create its OpenGL context
    *window = glfwCreateWindow(1280, 720, "CONTROL-X", NULL, NULL);
    if (*window == NULL) {
        fprintf(stderr, "Failed to open GLFW window.\n");
        glfwTerminate();
        return -1;
    }

    glfwMakeContextCurrent(*window);

    // Initialize GLEW
    if (glewInit() != GLEW_OK) {
        fprintf(stderr, "Failed to initialize GLEW\n");
        glfwTerminate();
        return -1;
    }

    // Ensure we can capture the escape key being pressed below
    glfwSetInputMode(*window, GLFW_STICKY_KEYS, GL_TRUE);

    // Dark grey background
    glClearColor(0.15f, 0.15f, 0.15f, 0.0f);

    return 0;
}

int
cx_glrun(GLFWwindow *window) {
    GLuint VertexArrayID;
    GLuint programID;
    if (cx_loadShaders(&VertexArrayID, &programID)) {
        return -1;
    }

    // Establish a model registry
    ModelRegistry *mr;
    mr = modelRegistry_new();
    for (int i = 0; i < 3; i++) {
        // Load model to render from file
        Model *model = model_load("../3d_assets/triangle.obj");
        GLfloat *rotation_matrix = matrix_new();
        GLfloat *translation_matrix = matrix_new();

        rotation_matrix[0] = cos(M_PI*2/256);
        rotation_matrix[8] = -sin(M_PI*2/256);
        rotation_matrix[2] = sin(M_PI*2/256);
        rotation_matrix[10] = cos(M_PI*2/256);

        translation_matrix[3] = -0.5 + (0.5 * i);

        model->transformations[0] = rotation_matrix;
        model->transformations[1] = translation_matrix;
        model->transformation_count = 2;
        model_colorFromPosition(model);

        modelRegistry_register(mr, model);
    }

    // Allocate the render buffer
    // GL uses this to feed the GPU


    // Remainder from cursor experiments, might be useful later
    double xpos, ypos;
    glfwGetCursorPos(window, &xpos, &ypos);

    int t = 0;

    do {
        cx_glrender(window, programID, mr);
        t++;
        usleep(1000000/60);
        // Check if the ESC key was pressed or the window was closed
    } while(glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS
            && !glfwWindowShouldClose(window));

    // Close OpenGL window and terminate GLFW
    glfwTerminate();
    modelRegistry_free(mr);

    return 0;
}

int
cx_nninit(Neural_Network **nn) {
    // Allocate a Neural Network
    *nn = neural_new(64, 1);
    if(!*nn) {
        fprintf(stderr, "Failed to initialize Neural Network.\n");
        return -1;
    }

    // Populate the neural network with sensible values.
    neural_randomize(*nn);

    return 0;
}

int
cx_nnrun(Neural_Network *nn) {

    // Establish a neural interface.
    float *input_buffer = malloc(64*sizeof(float));
    float *output_buffer;

    output_buffer = neural_process(nn, input_buffer);
    return 0;
}