import java.awt.List;
import java.util.ArrayList;

public class Filter {

    /*
     * En lista som innehåller listor. Till en början är den tom när vi skapar
     * den
     */
    private ArrayList<ArrayList<Double>> list;

    public Filter(ArrayList vector) {

        /*
         * Här kastar vi in den stora vektorn du har i den första platsen i
         * listan dvs index 0
         */
        this.list.add(vector);
    }

    public ArrayList<ArrayList<Double>> filter() {

        /*
         * Detta är bara lite hjälpvärden: subList: håller reda på vilken lista
         * det är vi befinner oss i just nu. 0 är den stora listan och 1 blir
         * listan vi skapar från orginalistan hasRemoved: säger bara om vi
         * faktiskt har hittat ett värde som behöver flyttas till en annan
         * lista. Om vi inte har flyttat på några värden så är vi klara med den
         * sista listan
         */
        int subList = 0;
        boolean hasRemoved = false;

        /*
         * while(true) för att vi avslutar vårt program med "return list;"
         * istället så vi fortsätter tills vi är klara helt enkelt
         */
        while (true) {

            /*
             * next: pekar alltid på nästa värde, vi skulle kunna bara använda
             * "i+1" istället men tyckte bara det var lättare att hålla reda på
             */
            int next = 0;
            /*
             * Efter varje lista vi gått igenom så sätter vi hasRemoved till
             * false igen
             */
            hasRemoved = false;

            /*
             * Här går vi igenom sub-listan och filtrerar den, vi börjar med den
             * stora vektorn (subList=0)
             */
            for (int i = 0; i < list.get(subList).size(); i++) {
                /*
                 * Öka värdet på next med 1 så att det faktiskt pekar på nästa
                 * värde
                 */
                next++;

                try {
                    /*
                     * Här händer det roliga. Vi tittar på om nästa värde (next)
                     * minus värdet vi är på (i) är mindre eller lika med 1. I
                     * så fall så lägger vi till nästa värde (next) i nästa
                     * sub-lista (sublist+1) och sedan tar vi bort värdet "next"
                     * från den listan vi är i, detta gör att alla värden efter
                     * i skiftas ett steg till vänster i listan för att fylla i
                     * tomrummet. Det betyder att "next" nu fortfarande pekar på
                     * nästa värde så vi behöver inte stega "next" igen utan vi
                     * gör samma jämförelse igen (next - i) och upprepar tills
                     * skillnaden mellan värdena är större än 1
                     */
                    while (list.get(subList).get(next) - list.get(subList).get(i) <= 1) {
                        list.get(subList + 1).add(list.get(subList).get(next));
                        list.get(subList).remove(next);

                        /*
                         * Om vi har kommit hit betyder det att vi har slängt
                         * över ett värde till nästa lista så vi är inte klara
                         * med vårt filter
                         */
                        hasRemoved = true;
                    }
                    /*
                     * När vi är på det sista elementet i listan och försöker
                     * använda get(next) så får vi felet
                     * IndexOutOfBoundsException. När detta händer så är det
                     * inte så farligt utan vi vill bara fortsätta så att
                     * istället för att programmet sla krasha när det händer så
                     * tar vi emot felet och gör inget. System.out.println är
                     * onödig här så den går att ta bort och bara lämna
                     * catch-satsen blank också.
                     */
                } catch (IndexOutOfBoundsException e) {
                    System.out.println("There was no next value.");
                }
            }
            /*
             * Så om vi har gått igenom en lista utan att skapa en ny lista så
             * är vi klara och vi returnerar vårt svar (list)
             */
            if (hasRemoved = false) {
                return list;
            }
            /*
             * Om vi gjorde en ändring i vår lista så är vi inte klara och vi
             * vill gå igenom nästa lista (subList + 1) så vi ökar värdet på
             * subList
             */
            subList++;

        }
    }

}