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

#include <iostream>
#include <string>
#include <sstream>
#include <fstream>

class Renderer {
public:
    bool init();
    bool init_window();
    void init_buffers();

    GLFWwindow* get_window();

    unsigned int compile_shader_from_file(const std::string&, GLenum);
    unsigned int compile_shader_from_string(const std::string&, GLenum);
    void compile_shader_program();

    void draw();

private:
    GLFWwindow* window;
    unsigned int vertex_buffer;
    unsigned int shader_program;
};

bool Renderer::init() {
    if(init_window()) {
        init_buffers();
        compile_shader_program();
        glUseProgram(shader_program);
        return true;
    }
    std::cout << "Failed to createGLFW3 window" << std::endl;
    return false;
}

bool Renderer::init_window() {
    //Init GLFW
    if (!glfwInit()) {
        std::cout << "Error initializing GLFW3." << std::endl;
        return false;
    }

    //Set up the window
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return false;
    }

    //Create OpenGL Context;
    glfwMakeContextCurrent(window);

    //Init GLEW
    GLenum glew_state = glewInit();
    if(glew_state != GLEW_OK){
        std::cout << "Error initializing GLEW: " << glewGetErrorString(glew_state) << std::endl;
        return false;
    }
    return true;
}

void Renderer::init_buffers() {
     //Initialize and set up the vertex buffer
    glGenBuffers(1, &vertex_buffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);

    //Vertex positions (X,Y)
    float verts[6] =  {
        -0.0f, -0.5f,
        -0.5f,  0.5f,
         0.5f,  0.5f
    };

    //Buffer vertex data
    glBufferData(GL_ARRAY_BUFFER, 6* sizeof(float), verts, GL_STATIC_DRAW);

    //Enable vertex attributes.
    glEnableVertexAttribArray(0);

    //Set Vertex attributes
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);
}

GLFWwindow* Renderer::get_window() {
    return window;
}

unsigned int Renderer::compile_shader_from_file(const std::string& file_path, GLenum shader_type) {
    std::ifstream shader_source_file(file_path);
    unsigned int shader = glCreateShader(shader_type);

    if(shader_source_file.is_open()) {
        //Read file into string
        std::ostringstream string_buffer;
        string_buffer << shader_source_file.rdbuf();
        std::string shader_source_code = string_buffer.str();

        //Create shader and feed it the source code
        unsigned int shader = glCreateShader(shader_type);
        const char* shader_source_code_c = shader_source_code.c_str();
        glShaderSource(shader, 1, &shader_source_code_c , nullptr);
        glCompileShader(shader);

        //Check for compile errors.
        int compile_status;
        glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
        if(compile_status != GL_TRUE) {
            int length;
            glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
            char shader_compile_error_message[length];
            glGetShaderInfoLog(shader, length, &length, shader_compile_error_message);
            std::cout << "Renderer::compile_shader() - Error: failed to compile " << (shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment") << "shader: " << shader_compile_error_message << std::endl;
            glDeleteShader(shader);
            return 0;
        }
    }
    shader_source_file.close();
    return shader;
}

unsigned int Renderer::compile_shader_from_string(const std::string& shader_source_code, GLenum shader_type) {
    std::cout << "Compiling " <<  (shader_type == GL_VERTEX_SHADER ? "vertex " : "fragment ") << "shader from string..." << std::endl;
    unsigned int shader = glCreateShader(shader_type);
    const char* shader_source_code_c = shader_source_code.c_str();
    glShaderSource(shader, 1, &shader_source_code_c , nullptr);
    glCompileShader(shader);

    int compile_status;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
    if(compile_status != GL_TRUE) {
        int length;
        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
        char shader_compile_error_message[length];
        glGetShaderInfoLog(shader, length, &length, shader_compile_error_message);
        std::cout << "Renderer::compile_shader() - Error: failed to compile " << (shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment") << "shader: " << shader_compile_error_message << std::endl;
        glDeleteShader(shader);
        return 0;
    }
    std::cout  << (shader_type == GL_VERTEX_SHADER ? "Vertex " : "Fragment ") << "shader successfully compiled from string." << std::endl;
    return shader;
}

void Renderer::compile_shader_program() {
    shader_program = glCreateProgram();

    std::string vertex_shader_source =
        "#version 300 es\n"
        "layout(location = 0) in vec4 verts;\n"
        "void main(){\n"
        "    gl_Position = verts;\n"
        "}\n";

    std::string fragment_shader_source =
        "#version 300 es\n"
        "precision mediump float;"
        "out vec3 color;\n"
        "void main() {\n"
        "    color = vec3(1,0,0);\n"
        "}\n";

    unsigned int vertex_shader = compile_shader_from_file("shaders/300_es.vert", GL_VERTEX_SHADER);
    unsigned int frgmnt_shader = compile_shader_from_file("shaders/300_es.frag", GL_FRAGMENT_SHADER);

    //Attach shaders to program
    glAttachShader(shader_program, vertex_shader);
    glAttachShader(shader_program, frgmnt_shader);

    glLinkProgram(shader_program);
    glValidateProgram(shader_program);

    //Error checking
    int program_validate_successful;
    glGetProgramiv(shader_program, GL_VALIDATE_STATUS, &program_compile_successful);
    if(program_validate_successful != GL_TRUE) {
        int length;
        glGetProgramiv(shader_program, GL_INFO_LOG_LENGTH, &length);
        char message[length];
        glGetProgramInfoLog(shader_program, length, &length, message);
        std::cout << "Error compiling shader program: " << message << std::endl;
    }

    //Cleanup
    glDeleteShader(vertex_shader);
    glDeleteShader(frgmnt_shader);
}

void Renderer::draw() {
    glClear(GL_COLOR_BUFFER_BIT);
    glDrawArrays(GL_TRIANGLES, 0, 3);
    glfwSwapBuffers(window);
}

int main() {
    Renderer r;

    if (!r.init()) {
        return -1;
    }

    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(r.get_window())) {
        r.draw();
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}