#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::Window 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);

    sf::Image image;
    image.loadFromFile("my_tex.tga");
    //image.flipVertically();

    GLuint texture = 0;
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.getSize().x, image.getSize().y, 0, GL_RGBA, GL_UNSIGNED_BYTE, image.getPixelsPtr());
    glBindTexture(GL_TEXTURE_2D, 0);

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

    std::vector<float> colorData {
        1.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 1.0f,
        1.0f, 1.0f, 0.0f
    };

    std::vector<float> texCoords {
        0.0f, 1.0f,
        0.0f, 0.0f,
        1.0f, 0.0f,
        1.0f, 1.0f
    };

    std::vector<unsigned int> iboData {
        0, 1, 2,
        0, 2, 3
    };

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

    GLuint vbo[3];
    glGenBuffers(3, vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
    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);

    GLuint ibo = 0;
    glGenBuffers(1, &ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(iboData[0]) * iboData.size(), iboData.data(), GL_STATIC_DRAW);;

    glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(colorData[0]) * colorData.size(), colorData.data(), GL_STATIC_DRAW);

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

    glBindBuffer(GL_ARRAY_BUFFER, vbo[2]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(texCoords[0]) * texCoords.size(), texCoords.data(), GL_STATIC_DRAW);

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

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

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

    GLint timeLocation = glGetUniformLocation(program, "time");
    GLint projectionLocation = glGetUniformLocation(program, "projection");
    GLint modelLocation = glGetUniformLocation(program, "model");

    glUseProgram(program);
    std::vector<float> projection {
        0.001953f,       0.0f,  0.0f, 0.0f,
             0.0f, -0.002604f,  0.0f, 0.0f,
             0.0f,       0.0f, -1.0f, 0.0f,
            -1.0f,       1.0f,  0.0f, 1.0f
    };
    glUniformMatrix4fv(projectionLocation, 1, GL_FALSE, projection.data());

    std::vector<float> model {
        200.0f,   0.0f, 0.0f, 0.0f,
          0.0f, 200.0f, 0.0f, 0.0f,
          0.0f,   0.0f, 1.0f, 0.0f,
         50.0f,  50.0f, 0.0f, 1.0f
    };
    glUniformMatrix4fv(modelLocation, 1, GL_FALSE, model.data());
    glUseProgram(0);

    sf::Clock clock{ };
    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);
        glBindTexture(GL_TEXTURE_2D, texture);
        glDrawElements(GL_TRIANGLES, iboData.size(), GL_UNSIGNED_INT, nullptr);
        glBindTexture(GL_TEXTURE_2D, 0);
        glBindVertexArray(0);

        glUniform1f(timeLocation, (float) clock.getElapsedTime().asSeconds());
        glUseProgram(0);

        window.display();
    }

    glDeleteTextures(1, &texture);
    glDeleteBuffers(3, vbo);
    glDeleteBuffers(1, &ibo);
    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.data());
        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;
}