package com.ecsbackgammon;

import android.opengl.GLES30;
import android.opengl.GLSurfaceView;
import android.opengl.Matrix;
import android.util.Log;

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

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

public class MyGLRenderer implements GLSurfaceView.Renderer {

    private String TAG = DrawThread.class.getSimpleName( );

    MyGLRenderer( )
    {
        fSampleVertices = ByteBuffer.allocateDirect( fSampleVerticesData.length * 4 )
                .order ( ByteOrder.nativeOrder( ) ).asFloatBuffer( );

        fSampleVertices.put( fSampleVerticesData ).position ( 0 );

        Log.d( TAG, "MyGLRender( )" );
    }

    public void onSurfaceCreated( GL10 unused, EGLConfig config )
    {
        RenderGL.CalculateBounds( );

        fBoardOuterData[0] = BoardMetrics.rBoardOuter.right;
        fBoardOuterData[1] = BoardMetrics.rBoardOuter.top;
        fBoardOuterData[2] = 0.0f;
        fBoardOuterData[3] = BoardMetrics.rBoardOuter.left;
        fBoardOuterData[4] = BoardMetrics.rBoardOuter.top;
        fBoardOuterData[5] = 0.0f;
        fBoardOuterData[6] = BoardMetrics.rBoardOuter.left;
        fBoardOuterData[7] = BoardMetrics.rBoardOuter.bottom;
        fBoardOuterData[8] = 0.0f;
        fBoardOuterData[9] = BoardMetrics.rBoardOuter.right;
        fBoardOuterData[10] = BoardMetrics.rBoardOuter.top;
        fBoardOuterData[11] = 0.0f;
        fBoardOuterData[12] = BoardMetrics.rBoardOuter.left;
        fBoardOuterData[13] = BoardMetrics.rBoardOuter.bottom;
        fBoardOuterData[14] = 0.0f;
        fBoardOuterData[15] = BoardMetrics.rBoardOuter.right;
        fBoardOuterData[16] = BoardMetrics.rBoardOuter.bottom;
        fBoardOuterData[17] = 0.0f;

        fBoardOuter = ByteBuffer.allocateDirect( fBoardOuterData.length * 4 )
                .order ( ByteOrder.nativeOrder( ) ).asFloatBuffer( );

        fBoardOuter.put( fBoardOuterData ).position ( 0 );

        String sVertexShader1 =
                  "#version 300 es 			    \n"
                 +   "uniform mat4 uMVPMatrix;   \n"
                + "in vec4 vPosition;           \n"
                + "void main()                  \n"
                + "{                            \n"
                + "   gl_Position = uMVPMatrix * vPosition;  \n"
                + "}                            \n";

        /*String sVertexShader1 =

                // This matrix member variable provides a hook to manipulate
                // the coordinates of objects that use this vertex shader.
                "#version 300 es 			    \n" +
                "uniform mat4 uMVPMatrix;   \n" +

                        "attribute vec4 vPosition;  \n" +
                        "void main(){               \n" +
                        // The matrix must be included as part of gl_Position
                        // Note that the uMVPMatrix factor *must be first* in order
                        // for the matrix multiplication product to be correct.
                        " gl_Position = uMVPMatrix * vPosition; \n" +

                        "}  \n";*/

        String sFragmentShader1 =
              "#version 300 es		 			          	\n"
            + "precision mediump float;					  	\n"
            + "out vec4 fragColor;	 			 		  	\n"
            + "void main()                                  \n"
            + "{                                            \n"
            + "  fragColor = vec4 ( 1.0, 0.0, 0.0, 1.0 );	\n"
            + "}                                            \n";

        int[] dLinked1 = new int[1];

        int dVertexShader1 = LoadShader ( GLES30.GL_VERTEX_SHADER, sVertexShader1 );

        int dFragmentShader1 = LoadShader ( GLES30.GL_FRAGMENT_SHADER, sFragmentShader1 );

        int dProgramObject1 = GLES30.glCreateProgram( );

        if ( dProgramObject1 == 0 )
        {
            return;
        }

        GLES30.glAttachShader ( dProgramObject1, dVertexShader1 );

        GLES30.glAttachShader ( dProgramObject1, dFragmentShader1 );

        GLES30.glBindAttribLocation( dProgramObject1, 0, "vPosition" );

        GLES30.glLinkProgram( dProgramObject1 );

        GLES30.glGetProgramiv( dProgramObject1, GLES30.GL_LINK_STATUS, dLinked1, 0 );

        if ( dLinked1[0] == 0 )
        {
            Log.e ( TAG, "Error linking program:" );
            Log.e ( TAG, GLES30.glGetProgramInfoLog ( dProgramObject1 ) );

            GLES30.glDeleteProgram ( dProgramObject1 );

            return;
        }

        this.dProgramObject1 = dProgramObject1;

        muMVPMatrixHandle = GLES30.glGetUniformLocation( dProgramObject1, "uMVPMatrix");

        GLES30.glClearColor ( 1.0f, 1.0f, 1.0f, 0.0f );

        Log.d( TAG, "onSurfaceCreated( )" );
    }

    public void onDrawFrame( GL10 unused )
    {
        GLES30.glViewport ( 0, 0, mWidth, mHeight );

        GLES30.glClear ( GLES30.GL_COLOR_BUFFER_BIT );

        GLES30.glUseProgram ( dProgramObject1 );

        GLES30.glVertexAttribPointer( 0, 3, GLES30.GL_FLOAT, false, 0, fSampleVertices );

        GLES30.glEnableVertexAttribArray ( 0 );

        GLES30.glUniformMatrix4fv( muMVPMatrixHandle, 1, false, fOrthoM, 0 );

        GLES30.glDrawArrays( GLES30.GL_TRIANGLES, 0, 3 );

        //Log.d( TAG, "onDrawFrame( )" );
    }

    public void onSurfaceChanged( GL10 unused, int width, int height )
    {
        mWidth = width;

        mHeight = height;

        float aspectRatio = ( float ) mWidth / (float) mHeight;

        Matrix.orthoM( fOrthoM, 0, -aspectRatio, aspectRatio, -1, 1, -1, 1 );

        Log.d( TAG, "onSurfaceChanged( )" );
    }

    private int LoadShader ( int dType, String sShaderSrc )
    {
        int dShader;

        int[] dCompiled = new int[1];

        // Create the shader object
        dShader = GLES30.glCreateShader ( dType );

        if ( dShader == 0 )
        {
            return 0;
        }

        // Load the shader source
        GLES30.glShaderSource ( dShader, sShaderSrc );

        // Compile the shader
        GLES30.glCompileShader ( dShader );

        // Check the compile status
        GLES30.glGetShaderiv( dShader, GLES30.GL_COMPILE_STATUS, dCompiled, 0 );

        if ( dCompiled[0] == 0 )
        {
            Log.e ( TAG, GLES30.glGetShaderInfoLog ( dShader ) );

            GLES30.glDeleteShader ( dShader );

            return 0;
        }

        return dShader;
    }

    float[] fOrthoM = new float[16];

    private int dProgramObject1;

    private int mWidth;

    private int mHeight;

    private FloatBuffer fSampleVertices;

    private final float[] fSampleVerticesData =
            { .8f, .8f, 0.0f, -.8f, .8f, 0.0f, -.8f, -.8f, 0.0f };

    private FloatBuffer fBoardOuter;

    private final float[] fBoardOuterData = new float[18];

    int muMVPMatrixHandle;
}