#include <GL/glew.h>
#include <GL/gl.h>
#include <SFML/Graphics.hpp>

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

GLuint createShaderProgram(const std::string& vertexShaderPath, const std::string& fragmentShaderPath);


int main() {
    sf::ContextSettings context{ 24, 8, 4, 3, 3 };

    sf::RenderWindow window{ sf::VideoMode{ 1024, 768 }, "title", sf::Style::Default, context };
    window.setVerticalSyncEnabled(true);
    window.setActive(true);

    GLenum err;

    glewExperimental = GL_TRUE;
    if ((err = glewInit()) != GLEW_OK) {
        std::cout << glewGetErrorString(err) << std::endl;
    }

    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

    std::vector<float> vertexData {
        -0.5f,  0.5f, 0.0f,
        -0.5f, -0.5f, 0.0f,
         0.5f, -0.5f, 0.0f,
         0.5f,  0.5f, 0.0f
    };

    GLuint vao = 0;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    GLuint vbo = 0;
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertexData[0]) * vertexData.size(), vertexData.data(), GL_STATIC_DRAW);

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);

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

    GLuint program = createShaderProgram("vert.glsl", "frag.glsl");

    sf::Event event{ };
    while (window.isOpen()) {
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                window.close();
            }
        }
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glUseProgram(program);
        glBindVertexArray(vao);
        glDrawArrays(GL_QUADS, 0, 4);
        glBindVertexArray(0);

        window.display();
    }

    glDeleteBuffers(1, &vbo);
    glDeleteVertexArrays(1, &vao);
    glDeleteProgram(program);

    return 0;
}

GLuint createShaderProgram(const std::string& vertexShaderPath, const std::string& fragmentShaderPath) {
    std::stringstream ss{ };
    std::string vertexShaderSource{ };
    std::string fragmentShaderSource{ };
    std::ifstream file{ vertexShaderPath };
    if (file.is_open()) {
        ss << file.rdbuf();
        vertexShaderSource = ss.str();
        file.close();
    }

    ss.str(std::string{ });
    file.open(fragmentShaderPath);
    if (file.is_open()) {
        ss << file.rdbuf();
        fragmentShaderSource = ss.str();
        file.close();
    }

    GLuint program = glCreateProgram();

    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

    const char* cVertexSource = vertexShaderSource.c_str();
    glShaderSource(vertexShader, 1, &cVertexSource, nullptr);
    glCompileShader(vertexShader);

    GLint logSize = 0;
    std::vector<GLchar> logText{ };
    glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &logSize);
    if (logSize > 0) {
        logText.resize(logSize);
        glGetShaderInfoLog(vertexShader, logSize, &logSize, &logText[0]);
        std::cout << logText.data() << std::endl;
    }

    const char* cFragmentSource = fragmentShaderSource.c_str();
    glShaderSource(fragmentShader, 1, &cFragmentSource, nullptr);
    glCompileShader(fragmentShader);

    logSize = 0;
    logText.clear();
    glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &logSize);
    if (logSize > 0) {
        logText.resize(logSize);
        glGetShaderInfoLog(fragmentShader, logSize, &logSize, &logText[0]);
        std::cout << logText.data() << std::endl;
    }

    glAttachShader(program, vertexShader);
    glAttachShader(program, fragmentShader);
    glLinkProgram(program);

    logSize = 0;
    logText.clear();
    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logSize);
    if (logSize > 0) {
        logText.resize(logSize);
        glGetProgramInfoLog(program, logSize, &logSize, &logText[0]);
        std::cout << logText.data() << std::endl;
    }

    glDetachShader(program, vertexShader);
    glDetachShader(program, fragmentShader);
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    return program;
}