#include <GL/glew.h>
#include <iostream>
#include <vector>
#include <fstream>
#include <string>
#include <GLFW/glfw3.h>
#include <GL/GL.h>

unsigned int g_programId = 0;
unsigned int g_vertexSaderId = 0, g_fragmentShaderId = 0;

unsigned int createShader(unsigned int type, const std::string &source)
{
    unsigned int _id = glCreateShader(type);

    auto _source = source.c_str();
    glShaderSource(_id, 1, &_source, 0);

    glCompileShader(_id);

    int _compile = false;
    glGetShaderiv(_id, GL_COMPILE_STATUS, &_compile);

    if (_compile == GL_FALSE)
    {
        int _length = 0;
        glGetShaderiv(_id, GL_INFO_LOG_LENGTH, &_length);

        std::vector<char> _info(_length);
        glGetShaderInfoLog(_id, _length, &_length, _info.data());

        std::cout << std::string(_info.begin(), _info.end()) << std::endl;

        glDeleteShader(_id);

        return 0;
    }

    return _id;
}

unsigned int createShaderProgram(const std::string &vertextShaderSource, const std::string &fragmentShaderSource)
{
    g_vertexSaderId = createShader(GL_VERTEX_SHADER, vertextShaderSource);
    g_fragmentShaderId = createShader(GL_FRAGMENT_SHADER, fragmentShaderSource);

    if (g_vertexSaderId && g_fragmentShaderId)
    {
        unsigned int _prgramId = glCreateProgram();

        glAttachShader(_prgramId, g_vertexSaderId);
        glAttachShader(_prgramId, g_fragmentShaderId);

        glLinkProgram(_prgramId);

        int _linked = 0;
        glGetProgramiv(_prgramId, GL_LINK_STATUS, &_linked);

        if (_linked == GL_FALSE)
        {
            int _length = 0;
            glGetProgramiv(_prgramId, GL_INFO_LOG_LENGTH, &_length);

            std::vector<char> _info(_length);
            glGetShaderInfoLog(_prgramId, _length, &_length, _info.data());

            std::cout << std::string(_info.begin(), _info.end()) << std::endl;

            glDeleteShader(g_vertexSaderId);
            glDeleteShader(g_fragmentShaderId);

            return 0;
        }

        glDetachShader(_prgramId, g_vertexSaderId);
        glDetachShader(_prgramId, g_fragmentShaderId);

        return _prgramId;
    }

    return 0;
}

void changeDisplayColor()
{
    glClearColor(1.0, 0.0, 0.0, 1.0);
    glClear(GL_COLOR_BUFFER_BIT);
}

void init()
{
    std::ifstream file;
    file.open("shaders/frag.glsl");

    std::string file_string;

    file >> file_string;
    std::cout << "Reading Shader...";
    std::cout << file_string;

    std::string _vertexShaderSource = file_string;
    std::string _fragmentShaderSource = "";

    g_programId = createShaderProgram(_vertexShaderSource, _fragmentShaderSource);

    std::cout << "PROGRAM ID: " << g_programId << std::endl;

}

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(1280, 720, "Shader", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    glewInit();
    init();

    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
        changeDisplayColor();

        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    glfwTerminate();
    glDeleteShader(g_vertexSaderId);
    glDeleteShader(g_fragmentShaderId);
    glDeleteProgram(g_programId);

    return 0;
}