#include "imagescrollareagl.h"
#include <QOpenGLFunctions>
#include <QDebug>
#include <QKeyEvent>
#include <QOpenGLDebugLogger>

ImageScrollAreaGL::ImageScrollAreaGL(QWidget *parent) : QOpenGLWidget(parent)
{
    setFocusPolicy(Qt::ClickFocus);
    m_range = UINT16_MAX;
    m_low = 0;
    m_high = 1;
}

ImageScrollAreaGL::~ImageScrollAreaGL()
{
    makeCurrent();
}

void ImageScrollAreaGL::setImage(RawImageAbs *image)
{
    m_image->destroy();
    m_image->setFormat(QOpenGLTexture::R16_UNorm);
    m_image->setSize(image->width(), image->height());
    m_image->setMinMagFilters(QOpenGLTexture::LinearMipMapLinear, QOpenGLTexture::Linear);
    m_image->allocateStorage();
    if(RawImage<uint8_t> *i8 = dynamic_cast<RawImage<uint8_t>*>(image))
    {
        m_image->setData(QOpenGLTexture::Red, QOpenGLTexture::UInt8, i8->data());
        m_range = UINT8_MAX;
    }
    else if(RawImage<uint16_t> *i16 = dynamic_cast<RawImage<uint16_t>*>(image))
    {
        m_image->setData(QOpenGLTexture::Red, QOpenGLTexture::UInt16, i16->data());
        m_range = UINT16_MAX;
    }
    else if(RawImage<uint32_t> *i32 = dynamic_cast<RawImage<uint32_t>*>(image))
    {
        m_image->setData(QOpenGLTexture::Red, QOpenGLTexture::UInt32, i32->data());
        m_range = UINT32_MAX;
    }
    m_image->generateMipMaps();
    repaint();
}

void ImageScrollAreaGL::setLow(int low)
{
    m_low = low/m_range;
    repaint();
}

void ImageScrollAreaGL::setHigh(int high)
{
    m_high = high/m_range;
    repaint();
}

void ImageScrollAreaGL::paintGL()
{
    float s = 1.0f/(m_high-m_low);
    m_program->bind();
    m_program->setUniformValue("scale", s, -m_low*s);

    m_image->bind(0);
    f->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}

void ImageScrollAreaGL::resizeGL(int w, int h)
{
    m_width = w;
    m_height = h;
    f->glViewport(0, 0, w, h);
}

void ImageScrollAreaGL::initializeGL()
{
    f = context()->functions();
    f->glClearColor(0.5f, 0.5f, 0.5f, 1.0f);

    m_vao = std::unique_ptr<QOpenGLVertexArrayObject>(new QOpenGLVertexArrayObject);
    m_vao->create();
    m_vao->bind();

    QOpenGLDebugLogger *logger = new QOpenGLDebugLogger(this);
    logger->initialize();
    logger->startLogging();
    connect(logger, &QOpenGLDebugLogger::messageLogged, [](const QOpenGLDebugMessage &message)
        {
            qDebug() << message;
        });

    qDebug() << (char*)f->glGetString(GL_VENDOR);
    qDebug() << (char*)f->glGetString(GL_RENDERER);
    qDebug() << (char*)f->glGetString(GL_VERSION);

    qDebug() << context()->format();

    // each vertex is  x,y 2D position and s,t texture coordinates
    float vertexs[] = {-1.0f, -1.0f, 0.0f, 1.0f,
                        1.0f, -1.0f, 1.0f, 1.0f,
                       -1.0f,  1.0f, 0.0f, 0.0f,
                        1.0f,  1.0f, 1.0f, 0.0f,};
    m_buffer = std::unique_ptr<QOpenGLBuffer>(new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer));
    m_buffer->setUsagePattern(QOpenGLBuffer::StaticDraw);
    m_buffer->create();
    m_buffer->bind();
    m_buffer->allocate(vertexs, sizeof(vertexs));
    f->glVertexAttribPointer(0, 2, GL_FLOAT, false, sizeof(float)*4, 0);

    m_program = std::unique_ptr<QOpenGLShaderProgram>(new QOpenGLShaderProgram);
    m_program->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/shaders/image.vert");
    m_program->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/shaders/image.frag");
    if(!m_program->link())
    {
        qDebug() << "Link failed" << m_program->log();
    }

    m_program->bind();
    m_program->enableAttributeArray("qt_Vertex");
    m_program->setAttributeBuffer("qt_Vertex", GL_FLOAT, 0, 2, sizeof(float)*4);
    m_program->enableAttributeArray("qt_MultiTexCoord0");
    m_program->setAttributeBuffer("qt_MultiTexCoord0", GL_FLOAT, sizeof(float)*2, 2, sizeof(float)*4);
    m_program->setUniformValue("qt_Texture0", (GLuint)0);
    m_program->setUniformValue("scale", 1.0f, 0.0f);

    m_image = std::unique_ptr<QOpenGLTexture>(new QOpenGLTexture(QImage("/home/nou/Obrázky/1p6yap.jpg")));
    m_image->bind(0);
    m_image->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
    m_image->setMagnificationFilter(QOpenGLTexture::Linear);
}