import std.stdio;
import std.file;
import std.math;
import derelict.util.exception;
import derelict.opengl3.gl3;
import derelict.glfw3.glfw3;

const GLfloat[] g_vertex_buffer_data = [
   -1.0f, -1.0f, 0.0f,
   1.0f, -1.0f, 0.0f,
   0.0f,  1.0f, 0.0f,
];

void main(string[] args) {
    DerelictGL3.load();
    DerelictGLFW3.load();
    if(!glfwInit()) {
        writefln("Could not initialize GLFW3.");
    }
    glfwInit();

    GLFWmonitor *monitor = glfwGetPrimaryMonitor();
    GLFWwindow *window = glfwCreateWindow(640, 480, "Test", null, null);
    glfwMakeContextCurrent(window);

    DerelictGL3.reload();

    GLuint VertexArrayID;
    glGenVertexArrays(1, &VertexArrayID);
    glBindVertexArray(VertexArrayID);

    glClearColor(0.0f, 0.0f, 0.4f, 0.0f);

    GLuint programID = LoadShaders( "vertex_shader", "fragment_shader" );

    while (!glfwWindowShouldClose(window)) {
        int width, height;
        glfwGetFramebufferSize(window, &width, &height);
        float ratio = width / cast(float) height;
        glViewport(0, 0, width, height);

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glUseProgram(programID);

        // This will identify our vertex buffer
        GLuint vertexbuffer;

        // Generate 1 buffer, put the resulting identifier in vertexbuffer
        glGenBuffers(1, &vertexbuffer);

        // The following commands will talk about our 'vertexbuffer' buffer
        glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);

        // Give our vertices to OpenGL.
        glBufferData(GL_ARRAY_BUFFER, g_vertex_buffer_data.length, cast(const(void *))g_vertex_buffer_data, GL_STATIC_DRAW);

        // 1rst attribute buffer : vertices
        glEnableVertexAttribArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
        glVertexAttribPointer(
           0,                  // attribute 0. No particular reason for 0, but must match the layout in the shader.
           3,                  // size
           GL_FLOAT,           // type
           GL_FALSE,           // normalized?
           0,                  // stride
           cast(void *)0       // array buffer offset
        );

        // Draw the triangle !
        glDrawArrays(GL_TRIANGLES, 0, 3); // Starting from vertex 0; 3 vertices total -> 1 triangle

        glDisableVertexAttribArray(0);

        glfwPollEvents();
        glfwSwapBuffers(window);
    }
}

GLuint LoadShaders(string vertex_file_path, string fragment_file_path){

    // Create the shaders
    GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
    GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);

    // Read the Vertex Shader code from the file
    const(char *) VertexShaderCode = cast(const(char *))readText(vertex_file_path);

    // Read the Fragment Shader code from the file
    const(char *) FragmentShaderCode = cast(const(char *))readText(fragment_file_path);

    GLint Result = GL_FALSE;
    int InfoLogLength;

    // Compile Vertex Shader
    writefln("Compiling shader : %s\n", vertex_file_path);
    glShaderSource(VertexShaderID, 1, &VertexShaderCode , null);
    glCompileShader(VertexShaderID);

    // Check Vertex Shader
    glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
    glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
    char[] VertexShaderErrorMessage;
    VertexShaderErrorMessage.length = InfoLogLength;
    glGetShaderInfoLog(VertexShaderID, InfoLogLength, null, &VertexShaderErrorMessage[0]);
    writefln("%s\n", &VertexShaderErrorMessage[0]);

    // Compile Fragment Shader
    writefln("Compiling shader : %s\n", fragment_file_path);
    glShaderSource(FragmentShaderID, 1, &FragmentShaderCode , null);
    glCompileShader(FragmentShaderID);

    // Check Fragment Shader
    glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
    glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
    char[] FragmentShaderErrorMessage;
    FragmentShaderErrorMessage.length = InfoLogLength;
    glGetShaderInfoLog(FragmentShaderID, InfoLogLength, null, &FragmentShaderErrorMessage[0]);
    writefln("%s\n", &FragmentShaderErrorMessage[0]);

    // Link the program
    writefln("Linking program\n");
    GLuint ProgramID = glCreateProgram();
    glAttachShader(ProgramID, VertexShaderID);
    glAttachShader(ProgramID, FragmentShaderID);
    glLinkProgram(ProgramID);

    // Check the program
    glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
    glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
    char[] ProgramErrorMessage;
    ProgramErrorMessage.length = cast(uint)fmax(InfoLogLength, 1);
    glGetProgramInfoLog(ProgramID, InfoLogLength, null, &ProgramErrorMessage[0]);
    writefln("%s\n", &ProgramErrorMessage[0]);

    glDeleteShader(VertexShaderID);
    glDeleteShader(FragmentShaderID);

    return ProgramID;
}