import java.util.ArrayList;
import java.util.Arrays;

import org.obsgolem.crystalia.gfx.Renderer;

import com.badlogic.gdx.graphics.Mesh;
import com.badlogic.gdx.graphics.VertexAttribute;
import com.badlogic.gdx.graphics.VertexAttributes.Usage;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.utils.Array;
import java.util.*;

public class MeshBatch
{

    private final static VertexAttribute[] attributeConfig = new VertexAttribute[]{
        new VertexAttribute(Usage.Position, 3, "a_position"),
        new VertexAttribute(Usage.ColorPacked, 4, "a_color"),
        new VertexAttribute(Usage.Normal, 3, "a_normal")};
    private final static int VERTEX_SIZE = 3 + 4 + 3;
//    static
//    {
//        int s = 0;
//        for(VertexAttribute va: attributeConfig)
//            s += va.getElementCount(); //don't know what this method is callind in libgdx or if it exsist.
//        VERTEX_SIZE = s;
//    }
    private Mesh m;
    private List<Float> vertices = new ArrayList<>();
    private List<Short> indices = new ArrayList<>();

    /**
     * why to you get a Short array instead of an primitiv?
     */
    public void addMesh(float[] vert, Short[] ind)
    {
        int offset = vertices.size() / VERTEX_SIZE;

        //You have to throw an exception when you get over the limit of short indices
        if (offset + vert.length / VERTEX_SIZE > Short.MAX_VALUE) {
            throw new RuntimeException("blablabla");
        }

        for (short i : addOffset(ind, offset)) {
            indices.add(i);
        }

        for (float v : vert) {
            vertices.add(v);
        }
    }

    public short[] addOffset(Short[] ind, int offset)
    {
        short[] indarr = new short[ind.length];
        for (int i = 0; i < ind.length; ++i) {
            //Do you really need this check? You are the only one using this code
            //so make sure that you never provide a null value. If you really want to have a chekc throw an exception instead
            short value = ind[i] == null ? 0 : ind[i];
            indarr[i] = (short) (value + offset);
        }
        return indarr;
    }

    /**
     * the finalize method is a reserved method in Java, it gets called by the
     * Garbage Collector when it destroys an Object.
     * <p/>
     * So don't use it ever for something other!!!
     */
    public void finalizeOtherNamePlease()
    {
        m = new Mesh(false, vertices.size(), indices.size(), attributeConfig);
        m.setVertices(Renderer.makeFloatArray(vertices));
        m.setIndices(Renderer.makeShortArray(indices));
    }

    /**
     * I don't want to talk about Globaltons right here, but this method is just
     * totaly useless. Rethink your design.
     */
    public void render()
    {
        Renderer.getInstance().render(m);
    }
}