package com.example.datalibrary.gl.shape;

import android.graphics.Rect;
import android.opengl.GLES11Ext;
import android.opengl.GLES20;

import com.example.datalibrary.gl.utils.ShaderUtils;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;


public class GLFrame {

    private int width;
    private int height;
    private int screenWidth;
    private int screenHeight;

    public float getWd() {
        return wd;
    }

    public float getHd() {
        return hd;
    }
    private float wd = 1;

    private float hd = 1;

    private float[] vertexData = {
            1f, -1f, 0f,
            -1f, -1f, 0f,
            1f, 1f, 0f,
            -1f, 1f, 0f
    };
    private final float[] textureVertexReverseData = {
            0f, 0f,
            1f, 0f,
            0f, 1f,
            1f, 1f,
    };
    private final float[] textureVertexData = {
            1f, 0f,
            0f, 0f,
            1f, 1f,
            0f, 1f
    };
    private FloatBuffer vertexBuffer;
    private int mirrorRGB;

    private FloatBuffer textureVertexBuffer;

    private int programId = -1;
    private int aPositionHandle;
    private int uTextureSamplerHandle;
    private int iTextureSamplerHandle;
    private int aTextureCoordHandle;
    private int uSTMMatrixHandle;

    private int sHandle;
    private int hHandle;
    private int lHandle;

    private int iHandle;


    private int[] vertexBuffers;



    private String fragmentShader = "#extension GL_OES_EGL_image_external : require\n" +
            "varying highp vec2 vTexCoord;\n" +
            "uniform samplerExternalOES sTexture;\n" +
            "uniform sampler2D iTexture;\n" +
            "uniform highp mat4 usTMatrix;\n" +
            "uniform highp float S;\n" +
            "uniform highp float H;\n"+
            "uniform highp float L;\n"+
            "uniform highp float i;\n"+
            "highp vec3 rgb2hsv(highp vec3 c){\n" +
            "    highp vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n" +
            "    highp vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));\n" +
            "    highp vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));\n" +
            "    highp float d = q.x - min(q.w, q.y);\n" +
            "    highp float e = 1.0e-10;\n" +
            "    return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);\n" +
            "}\n" +
            "highp vec3 hsv2rgb(highp vec3 c){\n" +
            "    highp vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n" +
            "    highp vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n" +
            "    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n" +
            "}"+
            "void main() {\n" +
            "    highp vec2 tx_transformed = (usTMatrix * vec4(vTexCoord, 0, 1.0)).xy;\n" +
            "    highp vec4 video = texture2D(sTexture ,  tx_transformed);\n" +
            "    highp vec4 rgba;\n"+
            "    if(i == 0.0){\n" +
            "       rgba = video;\n" +
            "    }\n"+
            "    else{\n" +
            "       highp vec4 image = texture2D(iTexture ,  vTexCoord);\n" +
            "       rgba = mix(video,image , image.a);\n"+
            "    }\n"+
            "    highp vec3 hsl = rgb2hsv(rgba.xyz);\n"+
            "    if(H != 0.0)hsl.x = H;\n" +
            "    if(hsl.x<0.0)hsl.x = hsl.x+1.0;\n" +
            "    else if(hsl.x>1.0)hsl.x = hsl.x-1.0;\n"+
            "    if(S != 1.0)hsl.y = hsl.y*S;\n"+
            "    highp vec3 rgb = hsv2rgb(hsl);\n" +
            "    if (L < 0.0) rgb = rgb + rgb * vec3(L);\n"+
            "    else rgb = rgb + (1.0 - rgb) * vec3(L);\n"+
            "    gl_FragColor = vec4(rgb,rgba.w);\n" +
            "}";
    private  String vertexShader = "attribute vec4 aPosition;\n" +
            "attribute vec2 aTexCoord;\n" +
            "varying vec2 vTexCoord;\n" +
            "void main() {\n" +
            "    vTexCoord = aTexCoord;\n" +
            "    gl_Position = aPosition;\n" +
            "}";

    private void againInit(){
        vertexBuffer = ByteBuffer.allocateDirect(vertexData.length * 4)
                .order(ByteOrder.nativeOrder())
                .asFloatBuffer()
                .put(vertexData);
        vertexBuffer.position(0);


        if (mirrorRGB == 0){
            textureVertexBuffer = ByteBuffer.allocateDirect(textureVertexData.length * 4)
                    .order(ByteOrder.nativeOrder())
                    .asFloatBuffer()
                    .put(textureVertexData);
        }else {
            textureVertexBuffer = ByteBuffer.allocateDirect(textureVertexReverseData.length * 4)
                    .order(ByteOrder.nativeOrder())
                    .asFloatBuffer()
                    .put(textureVertexReverseData);
        }
        textureVertexBuffer.position(0);
        initFrame();
    }
    public GLFrame(int mirrorRGB){
        vertexBuffer = ByteBuffer.allocateDirect(vertexData.length * 4)
                .order(ByteOrder.nativeOrder())
                .asFloatBuffer()
                .put(vertexData);
        vertexBuffer.position(0);
        this.mirrorRGB = mirrorRGB;
        if (mirrorRGB == 0){
            textureVertexBuffer = ByteBuffer.allocateDirect(textureVertexData.length * 4)
                    .order(ByteOrder.nativeOrder())
                    .asFloatBuffer()
                    .put(textureVertexData);
        }else {
            textureVertexBuffer = ByteBuffer.allocateDirect(textureVertexReverseData.length * 4)
                    .order(ByteOrder.nativeOrder())
                    .asFloatBuffer()
                    .put(textureVertexReverseData);
        }
        textureVertexBuffer.position(0);
    }
    public void initFrame(){
        programId = ShaderUtils.createProgram(vertexShader, fragmentShader);
        aPositionHandle = GLES20.glGetAttribLocation(programId, "aPosition");
        uSTMMatrixHandle = GLES20.glGetUniformLocation(programId, "usTMatrix");
        uTextureSamplerHandle = GLES20.glGetUniformLocation(programId, "sTexture");
        iTextureSamplerHandle = GLES20.glGetUniformLocation(programId, "iTexture");
        aTextureCoordHandle = GLES20.glGetAttribLocation(programId, "aTexCoord");
        sHandle = GLES20.glGetUniformLocation(programId , "S");
        hHandle = GLES20.glGetUniformLocation(programId , "H");
        lHandle = GLES20.glGetUniformLocation(programId , "L");

        iHandle = GLES20.glGetUniformLocation(programId , "i");

        vertexBuffers = new int[2];
        GLES20.glGenBuffers(2 , vertexBuffers , 0);
        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vertexBuffers[0]);
        GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, vertexData.length * 4, vertexBuffer , GLES20.GL_STATIC_DRAW);

        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vertexBuffers[1]);
        GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, textureVertexData.length * 4,
                textureVertexBuffer , GLES20.GL_STATIC_DRAW);
        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
    }

    private float s = 1.0f;
    public void setS(float s){
        this.s = s;
    }
    private float h = 0.0f;
    public void setH(float h) {
        this.h = h;
    }
    private float l = 1.0f;
    public void setL(float l) {
        this.l = l;
    }

    private boolean isInit;
    private Rect rect = new Rect();
    public void setSize(int screenWidth , int screenHeight , int videoWidth , int videoHeight){
        if (isInit){
            return;
        }
        isInit = true;
        this.screenWidth = screenWidth;
        this.screenHeight = screenHeight;
        this.width = videoWidth;
        this.height = videoHeight;
        if (screenHeight > screenWidth && videoWidth > videoHeight){
            wd = (float) screenHeight / (float) videoHeight;

        }else if (screenHeight < screenWidth && videoWidth < videoHeight){
            hd = (float) screenWidth / (float) videoWidth;
        }else if (videoWidth < screenWidth && videoHeight < screenHeight){
            float ywd = (float) videoWidth / (float) screenWidth;
            float yhd = (float) videoHeight / (float) screenHeight;
            float ywd1 = 1 - ywd;
            float yhd1 = 1 - yhd;
            if (ywd > yhd){
                wd = ywd + yhd1;
            }else {
                hd += yhd + ywd1;
            }
        }
//        vertexData = new float[]{
//                1f, -1f, 0f,
//                -1f, -1f, 0f,
//                1f, 1f, 0f,
//                -1f, 1f, 0f
//        };
        vertexData = new float[]{
                wd, -hd, 0f,
                -wd, -hd, 0f,
                wd, hd, 0f,
                -wd, hd, 0f
        };
        againInit();
        rect();
    }

    public void correctSize(int videoWidth , int videoHeight){
        if (this.width == videoWidth && this.height == videoHeight){
            return;
        }
//        setSize(screenHeight , screenWidth , videoWidth , videoHeight);
    }

    private void rect(){
        /*int left,top,viewWidth,viewHeight;
        float sh = screenWidth*1.0f/screenHeight;
        float vh = width *1.0f/ height;
        if(sh < vh){
            left = 0;
            viewWidth = screenWidth;
            viewHeight = (int)(height *1.0f/ width *viewWidth);
            top = (screenHeight - viewHeight)/2;
        }else{
            top = 0;
            viewHeight = screenHeight;
            viewWidth = (int)(width *1.0f/ height *viewHeight);
            left = (screenWidth - viewWidth)/2;
        }*/
//        rect.left = 0;
//        rect.top = 0;
//        rect.right = screenWidth;
//        rect.bottom = screenHeight;

        rect.left = 0;
        rect.top = 0;
        rect.right = screenWidth;
        rect.bottom = screenHeight;
    }

    public void drawFrame(int tId , int textureId , float[] sTMatrix){
        GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
        GLES20.glViewport(rect.left, rect.top, rect.right, rect.bottom);
        GLES20.glUseProgram(programId);
        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vertexBuffers[0]);
        GLES20.glEnableVertexAttribArray(aPositionHandle);
        GLES20.glVertexAttribPointer(aPositionHandle ,  3, GLES20.GL_FLOAT, false , 
                0, 0);

        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vertexBuffers[1]);
        GLES20.glEnableVertexAttribArray(aTextureCoordHandle);
        GLES20.glVertexAttribPointer(aTextureCoordHandle ,  2, GLES20.GL_FLOAT, false ,  0, 0);
        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);

        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES ,  textureId);
        GLES20.glUniform1i(uTextureSamplerHandle , 0);
        GLES20.glUniformMatrix4fv(uSTMMatrixHandle ,  1, false ,  sTMatrix, 0);

        GLES20.glActiveTexture(GLES20.GL_TEXTURE1);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, tId);
        GLES20.glUniform1i(iTextureSamplerHandle , 1);

        GLES20.glUniform1f(sHandle , s);
        GLES20.glUniform1f(hHandle , h);
        GLES20.glUniform1f(lHandle , l);
        GLES20.glUniform1f(iHandle , tId);

        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
    }

    public void release(){
        if (vertexBuffers == null){
            return;
        }
        GLES20.glDeleteProgram(programId);
        GLES20.glDeleteBuffers(2 , vertexBuffers , 0);
    }
}