package net.neilcsmith.slick;

import java.io.File;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;

import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL12.GL_CLAMP_TO_EDGE;

import org.gstreamer.Gst;
import org.gstreamer.elements.PlayBin2;
import org.gstreamer.elements.RGBDataSink;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import org.newdawn.slick.opengl.Texture;
import org.newdawn.slick.opengl.TextureImpl;

public class GStreamer_TestPlayer {

    private int WIDTH, HEIGHT;
    private int texture;
    private ByteBuffer buffer;
    private long before, msLength;
    private boolean done = false;
    private PlayBin2 playbin;

    public GStreamer_TestPlayer(int _w, int _h, String strToPlay, long _msLength) {
        WIDTH = _w;
        HEIGHT = _h;
        msLength = _msLength;

        buffer = BufferUtils.createByteBuffer(WIDTH * HEIGHT * 4);



        //Gstreamer stuff
//      try   {   LibraryLoaderImpl.getInstance().load();   } catch (Exception e){e.printStackTrace();}

        Gst.init("VideoPlayer", new String[]{});
        playbin = new PlayBin2("VideoPlayer");

        RGBListener listener = new RGBListener();
        playbin.setInputFile(new File(strToPlay));

        RGBDataSink sink = new RGBDataSink(("sink"), listener);
        sink.setPassDirectBuffer(true);
        playbin.setVideoSink(sink);

        Gst.getExecutor().execute(new Runnable() {

            public void run() {
                playbin.play();
            }
        });
    }

    public boolean isDone() {
        return done;
    }

    public void update() {

        Texture lastUsed = TextureImpl.getLastBind();
        TextureImpl.unbind();

        if (texture == 0) {
            texture = glGenTextures();
            glEnable(GL_TEXTURE);
            glBindTexture(GL_TEXTURE_2D, texture);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, WIDTH, HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
        }

        float scaleFactor = 1.0f;
        if (Display.getWidth() >= Display.getHeight()) {
            scaleFactor = (float) Display.getHeight() / (float) HEIGHT;
        } else {
            scaleFactor = (float) Display.getWidth() / (float) WIDTH;
        }

        glClear(GL_COLOR_BUFFER_BIT);

        glBindTexture(GL_TEXTURE_2D, texture);

        synchronized (buffer) {
            buffer.rewind();

            GL11.glTexSubImage2D(GL11.GL_TEXTURE_2D,
                    0,
                    0,
                    0,
                    WIDTH,
                    HEIGHT,
                    GL12.GL_BGRA,
                    GL12.GL_UNSIGNED_INT_8_8_8_8_REV,
                    buffer);

        }



        float x1, x2, y1, y2;
        y1 = (Display.getHeight() - (HEIGHT * scaleFactor)) / 2.0f;
        y2 = y1 + HEIGHT * scaleFactor;

        x1 = (Display.getWidth() - (WIDTH * scaleFactor)) / 2.0f;
        x2 = x1 + WIDTH * scaleFactor;

        glBegin(GL_QUADS);
        {
            glTexCoord2f(0, 0);
            glVertex2f(x1, y1);

            glTexCoord2f(1, 0);
            glVertex2f(x2, y1);

            glTexCoord2f(1, 1);
            glVertex2f(x2, y2);

            glTexCoord2f(0, 1);
            glVertex2f(x1, y2);
        }
        glEnd();

        if (lastUsed != null) {
            lastUsed.bind();
        }

    }

    public void destroy() {
    }

    private class RGBListener implements RGBDataSink.Listener {

        public void rgbFrame(boolean preroll, int width, int height, IntBuffer rgb) {
            synchronized (buffer) {
                buffer.rewind();
                buffer.asIntBuffer().put(rgb);
            }

        }
    }
}