import java.util.Iterator;

public class Rekkehus<E> implements Iterable<E> {
    private int antall = 0;
    private Hus foerste, siste = null;

    // public void leggTil(E element) { // legger til p? slutten av lista
    //     Hus hus = new Hus(element);

    //     if (antall == 0) { // sjekker om lista er tom, da er det enkelt
    //         foerste = hus;
    //         siste = hus;
    //     }

    //     else {
    //         siste.settNeste(hus);
    //         hus.settForrige(siste);
    //         siste = hus;
    //     }

    //     antall++;
    // }

    public void leggTil(E element) { // En sortert prioritetsk?, fra minst til st?rst
        Hus hus = new Hus(element);

        if (antall() == 0) {
            foerste = siste = hus;
            antall++;
            hus.settPos(antall);
        }

        else {
            Hus peker = foerste; 
            antall++;

            while (peker.hentNeste() != null && peker.compareTo(hus) < 0) {
                peker = peker.hentNeste();
            }

            // peker er IKKE null OG (peker skal v?re ST?RRE enn hus ELLER peker = siste hus)

            //hvis peker er f?rste, m? vi sjekke p? nytt, for da har ikke while-l?kka blitt utf?rt

            if (peker == foerste && peker.compareTo(hus) > 0) { // m? sjekke om peker er st?rre enn hus, merk at krokodillen spiser motsatt retning i if-sjekken
                hus.settNeste(foerste);
                foerste.settForrige(hus);
                foerste = hus;
                hus.settPos(1);

                for (int i = peker.hentPos() + 1; i <= antall(); i++) {
                    peker.settPos(i);
                    peker = peker.hentNeste(); 
                }
            }

            // hvis peker er siste, m? vi sjekke p? nytt, for da vet vi ikke om den siste er st?rre enn hus, eller om peker bare stoppet der fordi peker.hentNeste() er null

            else if (peker == siste && peker.compareTo(hus) < 0) {
                siste.settNeste(hus);
                hus.settForrige(siste);
                siste = hus;
                hus.settPos(antall);
            }

            //hvis vi er et sted mellom foerste og siste, peker ER ST?RRE enn hus

            else {
                peker.hentForrige().settNeste(hus);
                hus.settForrige(peker.hentForrige());
                hus.settNeste(peker);
                peker.settForrige(hus);
                hus.settPos(peker.hentPos());

                for (int i = peker.hentPos() + 1; i <= antall(); i++) {
                    peker.settPos(i);
                    peker = peker.hentNeste();
                }
            }
        }
    }

    public void fjern() { // fjerner fra starten av lista

        if (antall == 1) {
            foerste = siste = null;
            antall--;
        }

        else if (antall > 1) {
            siste.hentForrige().settNeste(null);
            siste = siste.hentForrige();
            antall--;
        }
    }

    public String toString() { // returnerer info om rekken med hus
        String streng = "Rekken best?r av " + this.antall() + " hus: \n \n";
        if (antall() == 0) {
            return streng;
        }

        else {
            Hus peker = foerste;
            while (peker != null) {
                streng += peker.tegnHus() + "\n \n";
                peker = peker.hentNeste();
            }
        }
        return streng;
    }

    public int antall() { // Nytt 
        return antall;
    }

    @Override
    public Iterator<E> iterator() {
        return new RekkehusIterator();
    }

    // indre klasse som skal holde p? et element, vet ikke hvilken type 
    protected class Hus implements Comparable<Hus> { // ofte kalt Node
        Hus neste, forrige = null;
        E data;
        int posisjon;

        public Hus(E data) { // E kan v?re hvilken som helst type
            this.data = data;
        }

        public E hentData() {
            return data;
        }

        public void settNeste(Hus hus) {
            this.neste = hus;
        }

        public void settForrige(Hus hus) {
            this.forrige = hus;
        }

        public Hus hentNeste() {
            return neste;
        }

        public Hus hentForrige() {
            return forrige;
        }

        public String hentInfo() {
            String streng = "Hus: ";
            streng += data;
            return streng;
        }

         public String tegnHus() {
            String tegning = "   /\\ \n" + "  /  \\ \n" + " /____\\ \n" + "|      |\n"  + "|  " + data +  "   |\n" + "|______|";
            return tegning;
        }

        @Override 
        // For A.compareTo(B) --> Returnerer et positivt tall hvis A er st?rre enn B
        public int compareTo(Hus hus) {
            String hus1 = this.data.toString();
            String hus2 = hus.data.toString();
            return hus1.compareTo(hus2);
        }

        public void settPos(int posisjon) {
            this.posisjon = posisjon;
        }

        public int hentPos() {
            return posisjon;
        }
    }

    public class RekkehusIterator implements Iterator<E> {
        private Hus peker = foerste;

        @Override
        public boolean hasNext() {
            return peker != null;
        }

        @Override 
        public E next() {
            E data = peker.hentData();
            peker = peker.hentNeste();
            return data;
        }
    }






}