#ifndef _GLOUTPUT_H_
#define _GLOUTPUT_H_

#include <stdio.h>
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include "Image.h"
#include "options.h"

/*v0.9*/
class GLOutput
{
    private:
         unsigned long int lastUpdate;
         Image* image;
         GLuint texture;
         bool updated;
         static GLOutput * instance;
         GLOutput():lastUpdate(glutGet(GLUT_ELAPSED_TIME)), texture(-1), updated(true){}
        
        void createTexture()
        {
            glDeleteTextures(1, &texture);
            const float3* pixels = image->GetPixels();
            float* pixelsSimple = new float[3*image->GetWidth()*image->GetHeight()];
            for(int n = 0; n < image->GetHeight()*image->GetWidth(); n++)
            {
                pixelsSimple[n*3] = min(1.0, pow((pixels[n])[0], 1.0/2.2));
                pixelsSimple[n*3+1] = min(1.0, pow((pixels[n])[1], 1.0/2.2));
                pixelsSimple[n*3+2] = min(1.0, pow((pixels[n])[2], 1.0/2.2));//Gamma anwenden
            }
            glGenTextures( 1, &texture );
            glBindTexture( GL_TEXTURE_2D, texture );
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
            glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, image->GetWidth(), image->GetHeight(), 0, GL_RGB, GL_FLOAT, pixelsSimple);
        }
        
        static void* outputThreadFunction(void* args)
        {
            int one = 1;
            glutInit(&one, NULL);
            glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGB| GLUT_DEPTH);
            glutInitWindowSize(GLOutput::getInstance()->image->GetWidth(),GLOutput::getInstance()->image->GetWidth());
            glutInitWindowPosition(0,0);
            glutCreateWindow("Fortschritt");
            glutDisplayFunc(&GLOutput::display);
            glutIdleFunc(&GLOutput::idle);
            glMatrixMode(GL_PROJECTION);
            glLoadIdentity();
            glViewport(0, 0, 1, 1);
            glOrtho(0, 1, 0, 1, 1, -1);
            glutMainLoop();
            return NULL;
        }

        static void idle(void)
        {
            glutPostRedisplay();
            //Set FPS
            unsigned long int dif;
            while((dif =(glutGet(GLUT_ELAPSED_TIME) - GLOutput::getInstance()->lastUpdate)) < FRAME_DURATION)
            {
                usleep(dif*1000);
            }
            GLOutput::getInstance()->lastUpdate = glutGet(GLUT_ELAPSED_TIME);
        }
        
        static void display(void)
        {
            if(GLOutput::getInstance()->updated)
            {
                GLOutput::getInstance()->createTexture();
                GLOutput::getInstance()->updated = false;
            }
            glEnable( GL_TEXTURE_2D );
            glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
            glClear(GL_COLOR_BUFFER_BIT);
            glColor3f(1.0f, 1.0f, 1.0f);
            glBegin( GL_QUADS );
            glTexCoord2f(0.0,0.0); 
            glVertex2f(0.0,0.0);
            glTexCoord2f(1.0,0.0); 
            glVertex2f(1.0,0.0);
            glTexCoord2f(1.0,1.0); 
            glVertex2f(1.0, 1.0);
            glTexCoord2f(0.0,1.0); 
            glVertex2f(0.0,1.0);
            glEnd();
            glFlush();
            glutSwapBuffers();
        } 
        
    public:
        void setImage(Image* image)
        {
            this->image = image;
        }
    
        void setUpdated()
        {
            this->updated = true;
        }
        
        pthread_t start()
        {
            pthread_t pth;
            pthread_create(&pth, NULL, &GLOutput::outputThreadFunction, NULL);
            return pth;
        }
        
        static GLOutput* getInstance()
        {
            if(GLOutput::instance == NULL)
            {
                GLOutput::instance = new GLOutput();
            }
            return GLOutput::instance;
        }
};

GLOutput* GLOutput::instance = NULL;
#endif