/*
Feladat:
--------

Valósitsd meg a LinkedList osztályt az alábbi feltételek mellett:
Helyez a LinkedList osztályodat egy LinkedList.java állományban. Az osztály a gyak05.adt csomagban van.
A listát egy double tömb reprezentálja. Ez osztályon kívülrõl elérhetetlen.
Új elem beszúrása esetén allokáljuk újra a tömböt, már ezzel az új elemmel kiegészítve.
Implementáld az alábbi metódusokat:
insert(elem); insert(double[]); remove(index); remove(startindex, endindex);
eq(LinkedList); subList(LinkedList); get(index); subSet(LinkedList);
toString() : String:
elem | elem | elem ...

Main.java
Main osztály a gyak05 csomagban.
Használjuk benne a LinkedListet és mutassuk be a metódusainak a mûködését.
args: ellenõrizzük, hogy kapunk-e paramétert, és ha kapunk, akkor azokat szúrjuk be a listába.
Ez mûködjön az args méretétõl függetlenül.
*/

package gyak05.adt;

public class LinkedList {
    private double[] list;

    public LinkedList() {
        this.list = new double[0];
    }

    public void insert(double e) {
        double[] tmp = list; // tmp ua mint a list! Csak elemek másolódnak.
        list = new double[tmp.length + 1]; // +1 hely az új elemnek.
        for(int i=0; i < tmp.length; ++i) {
            list[i] = tmp[i];
        }
        list[list.length-1] = e;
    }

    public void insert(double[] pList) {
        double[] tmp = this.list;
        this.list = new double[tmp.length + pList.length];
        for(int i=0; i<tmp.length; ++i) {
            this.list[i] = tmp[i];
        }
        for(int i=0; i<pList.length; ++i) {
            this.list[tmp.length + i] = pList[i];
        }
    }

    public int size() {
        return this.list.length;
    }

    public double get(int index) {
        return list[index];
    }

    public void remove(int index) {
        if(index < this.list.length) {
            double[] tmp = list;
            for(int i = index; i < list.length - 1; ++i) {
                tmp[i] = tmp[i+1];
            }
            list = new double[tmp.length - 1];
            for(int i=0; i<list.length; ++i) {
                list[i] = tmp[i];
            }
        }
    }

    // endindex-en levo elem bent marad!!!
    public void remove(int startindex, int endindex) {
        double[] tmp = this.list;
        this.list = new double[this.list.length - endindex + startindex];
        for(int i=0; i<startindex; ++i) {
            this.list[i] = tmp[i];
            System.out.println(this.list[i]);
        }
        for(int i=endindex; i<tmp.length; ++i) {
            this.list[i - startindex + 1] = tmp[i];
        }

    }

    public boolean eq(LinkedList ll) {
        for(int i=0; i<this.list.length; ++i) {
            if(this.list[i] != ll.get(i)) {
                return false;
            }
        }
        return true;
    }

    // Nem ellenorzom, hgy a sublist hosszabb-e mint a list-em.
    public boolean subList(LinkedList ll) {
        outer:
        for(int i=0; i<this.list.length - ll.size(); ++i) {
            for(int j=i; j<i+ll.size(); ++j) {
                if(this.list[j] != ll.get(j-i)) {
                        continue outer;
                }
            }
            return true;
        }
        return false;
    }

    public boolean subSet(LinkedList ll) {
        double[] thisSet = getSet(this);
        double[] pSet = getSet(ll);
        outer:
        for(double p : pSet) {
            for(double d : thisSet) {
                if ( d == p ) {
                    continue outer;
                }
            }
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for(double d : list) {
            sb.append(d); sb.append("|");
        }
        return sb.toString();
    }

    private double[] getSet(LinkedList ll) {
        double[] setOfThis = new double[0];
        outer:
        for(int i=0; i<ll.size(); ++i) {
            for(int j=0; j<setOfThis.length; ++j) {
                if(ll.get(i) == setOfThis[j]) {
                    continue outer;
                }
            }
            double[] tmp = setOfThis;
            setOfThis = new double[tmp.length + 1];
            for(int k=0; k<tmp.length; ++k) {
                setOfThis[k] = tmp[k];
            }
            setOfThis[setOfThis.length - 1] = ll.get(i);
        }
        return setOfThis;
    }

}