#ifndef GLUT2_IMAGE_H
#define GLUT2_IMAGE_H

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

#include <fstream>
#include <iomanip>


GLuint glob_program;
GLuint glob_texture;
bool once = false;

void draw() {
    if (once) {
        return;
    }
    once = true;
    gl(glBindImageTexture(0, glob_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY,
        GL_RGBA16UI));

    std::cout << "glob_program is progam "
        << (glIsProgram(glob_program) == GL_TRUE)
        << std::endl;
    GLint uniformTexPosition = gl(glGetUniformLocation(glob_program, "u_image"));
    std::cout << "u_image position " << uniformTexPosition << std::endl;
    gl(glUseProgram(glob_program));
    gl(glUniform1i(uniformTexPosition, 0));
    gl(glDispatchCompute(32, 32, 1));

    // bind and get texture
    gl(glBindTexture(GL_TEXTURE_2D, glob_texture));

    GLint texFormat;
    GLint texWidth;
    GLint texHeight;
    gl(glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT,
        &texFormat));
    gl(glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &texWidth));
    gl(glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT,
        &texHeight));

    size_t size;
    switch (texFormat) {
        case GL_RGBA16UI:
            size = 8;
            std::cout << "GL_RGBA16UI" << std::endl;
            break;
        default:
            size = 16;
            std::cout << "GL ENUM 0x"
                << std::hex << texFormat
                << std::scientific << std::endl;
            break;
    }

    size = texWidth * texHeight * size;
    std::cout << "Texture size " << size << "B" << std::endl;
    GLbyte *data = new GLbyte[size];

    gl(glGetTexImage(GL_TEXTURE_2D, 0, texFormat, GL_UNSIGNED_BYTE, data));

    std::ofstream stream("out.tex", std::ios::trunc | std::ios::binary);
    stream.write(reinterpret_cast<char *>(data), size);
    stream.close();
    delete[] data;
}

void initTextures() {
    gl(glGenTextures(1, &glob_texture));
    gl(glBindTexture(GL_TEXTURE_2D, glob_texture));
    gl(glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA16UI, 32, 32));
}

void initShader() {
    const GLchar *compShaderT =
        "#version 440 core\n"
        "layout (local_size_x = 32, local_size_y = 32) in;\n"
        "layout (location = 1, rgba16ui) uniform uimage2D u_image;\n"
        "uniform atomic_uint u_counter;\n"
        "void main() {\n"
            "uint value = atomicCounterIncrement(u_counter);\n"
            "ivec2 size = imageSize(u_image);\n"
            "if (gl_GlobalInvocationID.x < size.x && gl_GlobalInvocationID.y < size.y)"
            "imageStore(u_image, ivec2(gl_GlobalInvocationID.xy), "
                "uvec4(vec3(value), 0xffff));"
        "}\n";

    GLuint computeShader = gl(glCreateShader(GL_COMPUTE_SHADER));
    gl(glShaderSource(computeShader, 1, &compShaderT, nullptr));
    gl(glCompileShader(computeShader));

    glShaderLog(computeShader);
    glob_program = gl(glCreateProgram());
    gl(glAttachShader(glob_program, computeShader));
    gl(glLinkProgram(glob_program));

    gl(glDeleteShader(computeShader));

    glProgramLog(glob_program);
}

#endif