package southgrove.game.gridball;

import android.opengl.GLES20;
import android.opengl.Matrix;
import southgrove.droidgl.DroidGL;
import southgrove.droidgl.core.Material;
import southgrove.droidgl.core.Node;
import southgrove.droidgl.core.NodeBase;
import southgrove.droidgl.math.MathUtils;

public class Tetromino extends NodeBase implements Node
{

    public Tetromino(Types type, int gridPosX, int gridPosY, int gridPosZ, int gridRotation, Material material)
    {
        super(material);

        this.type = type;
        this.gridPosX = gridPosX;
        this.gridPosY = gridPosY;
        this.gridPosZ = gridPosZ;
        this.gridRotation = (int) MathUtils.wrap(gridRotation, 0, 4);
        this.points = getPoints(type, gridRotation);
    }

    @Override
    protected void onCreated()
    {
        // DO NOTHING ON GL SURFACE CREATION
    }

    @Override
    protected void onDraw()
    {
        final TetrominoMesh mesh = TetrominoMesh.getMesh(type);

        rotation.x += 0.34f;
        rotation.y += 0.4f;
        // rotation.z = gridRotation * 45;

        positionHandle = GLES20.glGetAttribLocation(material.getShader(), "aPosition");
        checkGlError("glGetAttribLocation aPosition");
        if (positionHandle == -1)
        {
            throw new RuntimeException("Could not get attrib location for aPosition");
        }

        textureHandle = GLES20.glGetAttribLocation(material.getShader(), "aTextureCoord");
        checkGlError("glGetAttribLocation aTextureCoord");
        if (textureHandle == -1)
        {
            throw new RuntimeException("Could not get attrib location for aTextureCoord");
        }

        mvpMatrixHandle = GLES20.glGetUniformLocation(material.getShader(), "uMVPMatrix");
        checkGlError("glGetUniformLocation uMVPMatrix");
        if (mvpMatrixHandle == -1)
        {
            throw new RuntimeException("Could not get attrib location for uMVPMatrix");
        }

        mesh.getVertexBuffer().position(TRIANGLE_VERTICES_DATA_POS_OFFSET);
        GLES20.glVertexAttribPointer(positionHandle, 3, GLES20.GL_FLOAT, false, TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mesh.getVertexBuffer());
        checkGlError("glVertexAttribPointer maPosition");

        mesh.getVertexBuffer().position(TRIANGLE_VERTICES_DATA_UV_OFFSET);
        GLES20.glEnableVertexAttribArray(positionHandle);
        checkGlError("glEnableVertexAttribArray positionHandle");

        GLES20.glVertexAttribPointer(textureHandle, 2, GLES20.GL_FLOAT, false, TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mesh.getVertexBuffer());
        checkGlError("glVertexAttribPointer textureHandle");

        GLES20.glEnableVertexAttribArray(textureHandle);
        checkGlError("glEnableVertexAttribArray textureHandle");

        Matrix.setIdentityM(modelMatrix, 0);
        Matrix.translateM(modelMatrix, 0, position.x, position.y, position.z);
        Matrix.rotateM(modelMatrix, 0, rotation.x, 1f, 0, 0);
        Matrix.rotateM(modelMatrix, 0, rotation.y, 0, 1f, 0);
        Matrix.rotateM(modelMatrix, 0, rotation.z, 0, 0, 1f);

        final float[] mvpMatrix = DroidGL.getActiveCamera().getModelViewProjectionMatrix(modelMatrix);
        GLES20.glUniformMatrix4fv(mvpMatrixHandle, 1, false, mvpMatrix, 0);

        //mesh.getVertexBuffer().position(0);
        //mesh.getIndexBuffer().position(0);

        GLES20.glDrawElements(GLES20.GL_TRIANGLES, mesh.getNumIndices(), GLES20.GL_UNSIGNED_SHORT, mesh.getIndexBuffer());
    }

    public void addToGrid(Grid gridBall)
    {
        for (int[] point : points)
        {
            final Cell c = gridBall.cell(gridPosX + point[0], gridPosY + point[1], gridPosZ);

            c.setIsTetrominoCenter(point[0] == 0 && point[1] == 0);
            c.setTetromino(this);
        }
    }

    public void removeFromGrid(Grid gridBall)
    {
        for (int[] point : points)
        {
            final Cell c = gridBall.cell(gridPosX + point[0], gridPosY + point[1], gridPosZ);

            c.setIsTetrominoCenter(false);
            c.setTetromino(null);
        }
    }

    public Types getType()
    {
        return type;
    }

    public int getGridPosX()
    {
        return gridPosX;
    }

    public int getGridPosY()
    {
        return gridPosY;
    }

    public int getGridPosZ()
    {
        return gridPosZ;
    }

    public int getGridRotation()
    {
        return gridRotation;
    }

    private Types               type;
    private int                 gridPosX                            = 0;
    private int                 gridPosY                            = 0;
    private int                 gridPosZ                            = 0;
    private int                 gridRotation                        = 0;
    private int[][]             points;

    private float[]             modelMatrix                         = new float[16];

    private int                 positionHandle;
    private int                 textureHandle;
    private int                 mvpMatrixHandle;

    private static final int    FLOAT_SIZE_BYTES                    = 4;
    private static final int    TRIANGLE_VERTICES_DATA_STRIDE_BYTES = 5 * FLOAT_SIZE_BYTES;
    private static final int    TRIANGLE_VERTICES_DATA_POS_OFFSET   = 0;
    private static final int    TRIANGLE_VERTICES_DATA_UV_OFFSET    = 3;

    public static enum Types
    {
        I, J, L, O, S, Z, T
    }

    protected static int[][] getPoints(Types type, int rotation)
    {
        switch (type)
        {
            case I:
                return I[(int) MathUtils.wrap(rotation, 0, 2)];

            case J:
                return J[(int) MathUtils.wrap(rotation, 0, 4)];

            case L:
                return L[(int) MathUtils.wrap(rotation, 0, 4)];

            case O:
                return O[0];

            case S:
                return S[(int) MathUtils.wrap(rotation, 0, 2)];

            case Z:
                return Z[(int) MathUtils.wrap(rotation, 0, 2)];

            case T:
                return T[(int) MathUtils.wrap(rotation, 0, 4)];

            default:
                return null;

        }
    }

    private final static int[][][]  I   = new int[][][] {
                                        { { 0, 1 }, { 0, 0 }, { 0, -1 }, { 0, -2 } },
                                        { { -1, 0 }, { 0, 0 }, { 1, 0 }, { 2, 0 } }
                                        };

    private final static int[][][]  J   = new int[][][] {
                                        { { 0, 1 }, { 0, 0 }, { -1, -1 }, { 0, -1 } },
                                        { { -1, 1 }, { -1, 0 }, { 0, 0 }, { 1, 0 } },
                                        { { 0, 1 }, { 1, 1 }, { 0, 0 }, { 0, -1 } },
                                        { { -1, 0 }, { 0, 0 }, { 1, 0 }, { 1, -1 } },
                                        };

    private final static int[][][]  L   = new int[][][] {
                                        { { 0, 1 }, { 0, 0 }, { 0, -1 }, { 1, -1 } },
                                        { { -1, 0 }, { 0, 0 }, { 1, 0 }, { -1, -1 } },
                                        { { -1, 1 }, { 0, 1 }, { 0, 0 }, { 0, -1 } },
                                        { { 1, 1 }, { -1, 0 }, { 0, 0 }, { 1, 0 } },
                                        };

    private final static int[][][]  O   = new int[][][] {
                                        { { 0, 0 }, { 1, 0 }, { 0, -1 }, { 1, -1 } }
                                        };

    private final static int[][][]  S   = new int[][][] {
                                        { { 0, 1 }, { 0, 0 }, { 1, 0 }, { 1, -1 } },
                                        { { 0, 1 }, { 1, 1 }, { -1, 0 }, { 0, 0 } }
                                        };

    private final static int[][][]  Z   = new int[][][] {
                                        { { 0, 1 }, { 0, 0 }, { -1, 0 }, { -1, -1 } },
                                        { { -1, 0 }, { 0, 0 }, { 0, -1 }, { 1, -1 } }
                                        };

    private final static int[][][]  T   = new int[][][] {
                                        { { -1, 0 }, { 0, 0 }, { 1, 0 }, { 0, -1 } },
                                        { { 0, 1 }, { -1, 0 }, { 0, 0 }, { 0, -1 } },
                                        { { 0, 1 }, { -1, 0 }, { 0, 0 }, { 1, 0 } },
                                        { { 0, 1 }, { 0, 0 }, { 1, 0 }, { 0, -1 } },
                                        };

    private final static String     TAG = "Tetromino";

}