#include <GL/glew.h>
#include <GL/gl.h>
#include <GL/glut.h>

#include <stdio.h>

// Global options: I need to put them in to a nicer place obv.
int width = 128;
int height = 128;

GLuint vao = 0;
GLuint vba = 0;
GLuint vbo = 0;
GLuint textureID = 0;

float* textureData = 0;

const unsigned int shaderAttribute = 0;

const char* vertexShaderSource =
    "#version 400\n"
    "in vec4 vertexPosition;\n"
    "out vec2 uv;\n"
    "void main() {\n"
    "  gl_Position = vertexPosition;\n"
    "  uv.x = (vertexPosition.x + 1.0) / 2;\n"
    "  uv.y = (vertexPosition.y + 1.0) / 2;\n"
    "}\n"
;

const char* fragmentShaderSource =
    "#version 400\n"
    "uniform sampler2D myTex;\n"
    "uniform vec4 baseColor;\n"
    "in vec2 uv;\n"
    "out vec4 fragColor;\n"
    "void main() {\n"
    "  fragColor = texture(myTex, uv);\n"
    "  fragColor += baseColor;\n"
    //  "  fragColor += vec4(uv.x, uv.y, 0, 1);\n"
    "}\n"
;

GLuint shaderProgram = 0;

void
draw()
{
    glClearColor(0, 0, 0, 0);
    glClear(GL_COLOR_BUFFER_BIT);

    glUseProgram(shaderProgram);
    glBindVertexArray(vao);

    // Setting up the texture sampler
    glEnable(GL_TEXTURE_2D);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, textureID);
    glUniform1i(glGetUniformLocation(shaderProgram, "myTex"), 0);

    glUniform4f(glGetUniformLocation(shaderProgram, "baseColor"), 0.5, 0.3, 0.8, 1.0);

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    glFlush();
}

void
setupGeometry()
{
    static GLfloat vertices[4][4] = {
        { -1.0, 1.0, 0.0, 1.0 },
        { -1.0, -1.0, 0.0, 1.0 },
        { 1.0, 1.0, 0.0, 1.0 },
        { 1.0, -1.0, 0.0, 1.0 },
    };

    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    glVertexAttribPointer(shaderAttribute, 4, GL_FLOAT, GL_FALSE, 0, 0);

    glEnableVertexAttribArray(shaderAttribute);
}

void
initGLUT()
{
    glutInitDisplayMode(GLUT_RGB);
    glutInitWindowSize(1920, 1080);
    glutCreateWindow("gl-view");
    glutDisplayFunc(draw);

    glewInit();

    setupGeometry();

    GLuint vertexShaderId = glCreateShader(GL_VERTEX_SHADER);
    GLint shaderLength = strlen(vertexShaderSource);
    glShaderSource(vertexShaderId, 1, &vertexShaderSource, &shaderLength);
    glCompileShader(vertexShaderId);

    GLuint fragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER);
    shaderLength = strlen(fragmentShaderSource);
    glShaderSource(fragmentShaderId, 1, &fragmentShaderSource, &shaderLength);
    glCompileShader(fragmentShaderId);

    shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShaderId);
    glAttachShader(shaderProgram, fragmentShaderId);
    glLinkProgram(shaderProgram);

    glEnable(GL_TEXTURE_2D);
    glGenTextures(1, &textureID);
    glBindTexture(GL_TEXTURE_2D, textureID);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, height, 0, GL_RGBA, GL_FLOAT, textureData);
}

float*
allocateTexture( size_t* expectedSize )
{
  *expectedSize = width * height * 4 * sizeof(float);
    float* res = malloc(*expectedSize);
    if (res == 0)
    {
        fprintf(stderr, "not enough memory to load file");
        return 0;
    }

    return res;
}

int
generateTexture(float** target)
{
    size_t expectedSize = 0;
    *target = allocateTexture(&expectedSize);
    if (*target == 0)
        return 0;

  float* textureValue = *target;
    for (int row = 0; row < height; ++row)
    {
        for (int column = 0; column < width; ++column, textureValue += 4)
        {
            textureValue[0] = (float)column / (float)width;
            textureValue[1] = (float)row / (float)height;
            textureValue[2] = 0;
            textureValue[3] = 1.0;
        }
    }

    return 1;
}

int
main(int argc, char** argv)
{
  generateTexture(&textureData);
    initGLUT();
    glutMainLoop();
    return 0;
}