#include <GL/glew.h>
#include <GL/gl.h>
#include <GL/glut.h>
#include <glm.hpp>
#include <gtc/matrix_transform.hpp>
#include <cstdio>
#include <fstream>

GLuint vaoHandle;
GLuint programHandle;
GLuint positionBufferHandle;
GLuint colorBufferHandle;

GLuint aPositionLocation;
GLuint aColorLocation;
GLuint uModelMatrixLocation;
GLuint uViewMatrixLocation;
GLuint uProjectionMatrixLocation;

glm::mat4 modelMatrix;
glm::mat4 viewMatrix;
glm::mat4 projectionMatrix;

void setupRC();

void initVBO();
void freeVBO();

void initShader();
void freeShader();
void shaderLog(GLuint shader);

void setModelMatrix();
void setViewMatrix();

void checkError();

void changeSize(int w, int h);
void renderScene();

std::string getFileContent(const char* fileName);

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
    glutInitWindowSize(500, 500);
    glutCreateWindow("GLEW Example");

    GLenum glew_status = glewInit();
    if (glew_status != GLEW_OK)
    {
        printf("Error: \"%s\"\n", glewGetErrorString(glew_status));
        return 1;
    }

    if (!GLEW_VERSION_2_0)
    {
        printf("No support for OpenGL 2.0 found!\n");
        return 1;
    }

    setupRC();
    initShader();
    initVBO();


    glutReshapeFunc(changeSize);
    glutDisplayFunc(renderScene);
    glutMainLoop();

    freeShader();
    freeVBO();
    printf("End of program...\n");
    return 0;
}

void setupRC()
{
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
}

void initVBO()
{
    float positionData[] =
        {
            -0.8f, -0.8f,
             0.8f, -0.8f,
             0.0f,  0.8f
        };
    float colorData[] =
        {
            1.0f, 0.0f, 0.0f,
            0.0f, 1.0f, 0.0f,
            0.0f, 0.0f, 1.0f
        };

    glGenVertexArrays(1, &vaoHandle);
    glBindVertexArray(vaoHandle);
    glEnableVertexAttribArray(aPositionLocation);
    glEnableVertexAttribArray(aColorLocation);
    checkError();

    glGenBuffers(1, &positionBufferHandle);
    glBindBuffer(GL_ARRAY_BUFFER, positionBufferHandle);
    glBufferData(GL_ARRAY_BUFFER, sizeof(positionData), positionData, GL_STATIC_DRAW);

    glVertexAttribPointer(aPositionLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
    checkError();

    glGenBuffers(1, &colorBufferHandle);
    glBindBuffer(GL_ARRAY_BUFFER, colorBufferHandle);
    glBufferData(GL_ARRAY_BUFFER, sizeof(colorData), colorData, GL_STATIC_DRAW);

    glVertexAttribPointer(aColorLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    checkError();

    glBindVertexArray(vaoHandle);
}

void freeVBO()
{
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glDeleteBuffers(1, &positionBufferHandle);
    glDeleteBuffers(1, &colorBufferHandle);
}

void initShader()
{
    std::string vertexShaderCode = getFileContent("./simple.vsh");
    const char* cStrVertexShaderCode = vertexShaderCode.c_str();

    std::string fragmentShaderCode = getFileContent("./simple.fsh");
    const char* cStrFragmentShaderCode = fragmentShaderCode.c_str();

    GLuint vShader, fShader;

    vShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vShader, 1, &cStrVertexShaderCode, 0);
    glCompileShader(vShader);
    printf("Vertex Shader Log:\n");
    shaderLog(vShader);
    printf ("End of vertex shader log.\n");

    fShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fShader, 1, &cStrFragmentShaderCode, 0);
    glCompileShader(fShader);
    printf("Fragment Shader Log:\n");
    shaderLog(fShader);
    printf("End of fragment shader log.\n");

    programHandle = glCreateProgram();
    glAttachShader(programHandle, vShader);
    glAttachShader(programHandle, fShader);
    glLinkProgram(programHandle);

    glDeleteShader(vShader);
    glDeleteShader(fShader);

    int link_ok;
    glGetProgramiv(programHandle, GL_LINK_STATUS, &link_ok);
    if (!link_ok)
    {
        printf("Error attach shaders!\n");
        return;
    }

    const char* aPositionName = "a_Position";
    aPositionLocation = glGetAttribLocation(programHandle, aPositionName);
    if (aPositionLocation == -1)
    {
        printf("Could not find attrib \"%s\"\n", aPositionName);
        return;
    }
    checkError();

    const char* aColorName = "a_Color";
    aColorLocation = glGetAttribLocation(programHandle, aColorName);
    if (aColorLocation == -1)
    {
        printf("Could not find attrib \"%s\"\n", aColorName);
        return;
    }
    checkError();

    const char* uModelMatrixName = "u_ModelMatrix";
    const char* uViewMatrixName = "u_ViewMatrix";
    const char* uProjectionMatrixName = "u_ProjectionMatrix";

    uModelMatrixLocation = glGetUniformLocation(programHandle, uModelMatrixName);
    uViewMatrixLocation = glGetUniformLocation(programHandle, uViewMatrixName);
    uProjectionMatrixLocation = glGetUniformLocation(programHandle, uProjectionMatrixName);

    if (uModelMatrixLocation == -1)
    {
        printf("Could not find uniform \"%s\"\n", uModelMatrixName);
        return;
    }

    if (uViewMatrixLocation == -1)
    {
        printf("Could not find uniform \"%s\"\n", uViewMatrixName);
        return;
    }

    if (uProjectionMatrixLocation == -1)
    {
        printf("Could not find uniform \"%s\"\n", uProjectionMatrixName);
        return;
    }

    setViewMatrix();
    setModelMatrix();

    glUseProgram(programHandle);
}

void freeShader()
{
    glUseProgram(0);
    glDeleteProgram(programHandle);
}

void shaderLog(GLuint shader)
{
    int infoLogLen = 0;
    int charsWritten = 0;
    char *infoLog;

    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLen);

    if (infoLogLen > 1)
    {
        infoLog = new char[infoLogLen];
        if (!infoLog)
        {
            printf("Error: \"Could not allocate InfoLog buffer\"\n");
            exit(1);
        }
        glGetShaderInfoLog(shader, infoLogLen, &charsWritten, infoLog);
        printf("InfoLog: \"%s\"\n", infoLog);
        delete[] infoLog;
    }
}

void setModelMatrix()
{
    modelMatrix = glm::mat4(1.0f);
}

void setViewMatrix()
{
    static glm::vec3 eye(0.0f, 0.0f, 1.5f);
    static glm::vec3 look(0.0f, 0.0f, 0.0f);
    static glm::vec3 up(0.0f, 1.0f, 0.0f);
    viewMatrix = glm::lookAt(eye, look, up);
}

void checkError()
{
    GLenum errCode = glGetError();
    if (errCode != GL_NO_ERROR)
    {
        printf("OpenGL error: \"%s\"\n", gluErrorString(errCode));
    }
}

void changeSize(int w, int h)
{
    if (w == 0) w = 1;
    if (h == 0) h = 1;

    float left, right, bottom, top, nearWall = 1.0f, farWall = 10.0f;
    if (w > h)
    {
        right = static_cast<float>(w) / h;
        left = -right;
        top = 1.0f;
        bottom = -1.0f;
    }
    else
    {
        right = 1.0f;
        left = -1.0f;
        top = static_cast<float>(h) / w;
        bottom = -top;
    }

    projectionMatrix = glm::frustum(left, right, bottom, top, nearWall, farWall);
}

void renderScene()
{
    glClear(GL_COLOR_BUFFER_BIT);

    glUniformMatrix4fv(uModelMatrixLocation, 1, GL_FALSE, &modelMatrix[0][0]);
    glUniformMatrix4fv(uViewMatrixLocation, 1, GL_FALSE, &viewMatrix[0][0]);
    glUniformMatrix4fv(uProjectionMatrixLocation, 1, GL_FALSE, &projectionMatrix[0][0]);

    glDrawArrays(GL_TRIANGLES, 0, 2 * sizeof(float));

    checkError();
    glutSwapBuffers();
}

std::string getFileContent(const char* fileName)
{
    std::ifstream stream(fileName);
    std::string content(std::istreambuf_iterator<char>(stream), (std::istreambuf_iterator<char>()));
    stream.close();
    return content;
}