import java.util.Iterator;

public class FIFOListe<T> implements Iterable<T>{

	private Node hode;
	private Node hale;
    private int storrelse;

	private class Node {
        Node neste;
        T verdi;
        Node(T verdi){
            this.verdi = verdi;
        }
    }



	public int storrelse(){
        // return storrelse;
        int teller = 0;
        for (Node tmp = hode; tmp != null; tmp = tmp.neste) {
            teller++;
        }
        return teller;
    }

    public int storrelseRek(){
        return storrelseRek(hode, 0);
    }

    public int storrelseRek(Node n, int antallSaaLangt){
        // Basistilfellet
        if (n == null){
            return antallSaaLangt;
        }
        // rekursjonssteg
        return storrelseRek(n.neste, antallSaaLangt+1);
    }


	public boolean erTom() {
        return hode == null;
    }

	public void leggTil(T x) {
        Node nyNode = new Node(x);
        if (erTom()){
            hode = nyNode;
        } else {
            hale.neste = nyNode;
        }
        hale = nyNode;
    }

	public void fjernAlt() {
        hode = null;
        hale = null;
    }

	public T pop(){
        T retur = hode.verdi;
        hode = hode.neste;
        return retur;
    }

	public void skrivUtListe() {
        Node gjeldende = hode;
        String penStreng = "[";
        while (gjeldende != null){
            penStreng += gjeldende.verdi.toString() + ", ";
            gjeldende = gjeldende.neste;
        }
        penStreng += "\b\b]";
        System.out.println(penStreng);
    }

    public void skrivUtRekursivt(){
        skrivUtRekursivt(hode);
    }

    public void skrivUtRekursivt(Node n){
        // Basistilfellet
        if (n == null){
            return;
        }
        // Oppgave
        System.out.println(n.verdi);
        // Rekursivt steg
        skrivUtRekursivt(n.neste);
    }

    public void skrivUtRekursivtBaklengs(){
        skrivUtRekursivtBaklengs(hode);
    }

    public void skrivUtRekursivtBaklengs(Node n){
        // Basistilfellet
        if (n == null){
            return;
        }
        // Rekursivt steg
        skrivUtRekursivtBaklengs(n.neste);
        // Oppgave
        System.out.println(n.verdi);
    }

    @Override
    public Iterator<T> iterator() {
        return new FIFOIterator();
    }

    private class FIFOIterator implements Iterator<T> {
        Node gjeldende = hode;

        @Override
        public boolean hasNext(){
            return gjeldende != null;
        }
        @Override
        public T next() {
            T returVerdi = gjeldende.verdi;
            gjeldende = gjeldende.neste;
            return returVerdi;
        }
    }
}