import java.awt.List;


public class Liste {

    private ListenElement kopf,schluss,aktuell;

    public Liste()
    {
        kopf = new ListenElement();
        schluss = new ListenElement();
        kopf.setNachfolger(schluss);
        aktuell = kopf;
        // eine Liste wird erzeugt.
    }
    boolean isEmpty()
    {
        if (kopf.getNachfolger() == schluss)
        {
            return true;
        }
        else
        {
            return false;
        }
    /**Die Anfrage liefert den Wert true, wenn die Liste keine Objekte enthält,
    sonst liefert sie den Wert false.*/

    }

    boolean hasAccess(){
        if(aktuell == kopf || aktuell == schluss)
        {
            return false;
        }
        else
        {
            return true;
        }
    /**Die Anfrage liefert den Wert true, wenn es ein aktuelles Objekt gibt,
    sonst liefert sie den Wert false.
    */
    }
    void next(){
        if(!this.isEmpty() && this.hasAccess())
        {
            aktuell = aktuell.getNachfolger();
        }
    /**Falls die Liste nicht leer ist, es ein aktuelles Objekt gibt und dieses
    nicht das letzte Objekt der Liste ist, wird das dem aktuellen Objekt in
    der Liste folgende Objekt zum aktuellen Objekt, andernfalls gibt es
    nach Ausführung des Auftrags kein aktuelles Objekt, d.h.
    hasAccess() liefert den Wert false.
    */
    }

    void toFirst(){
        if(!this.isEmpty())
        {
            aktuell = kopf.getNachfolger();
        }
    /**Falls die Liste nicht leer ist, wird das erste Objekt der Liste aktuelles
    Objekt. Ist die Liste leer, geschieht nichts.*/
    }

    void toLast()
    {
        if(!this.isEmpty())
        {
            while(!(aktuell.getNachfolger()== schluss))
            {
                this.next();
            }
        }
    /**Falls die Liste nicht leer ist, wird das letzte Objekt der Liste aktuelles
    Objekt. Ist die Liste leer, geschieht nichts.*/
    }

    Object getObject()
    {
        if(this.hasAccess())
        {
            return aktuell.getInhalt();
        }
        return null;
    /**Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das
    aktuelle Objekt zurückgegeben, andernfalls (hasAccess()==
    false) gibt die Anfrage den Wert null zurück.*/
    }

    void setObject(Object pObject)
    {
        if(this.hasAccess()&& pObject != null)
        {
            aktuell.setInhalt(pObject);
        }
    /**Falls es ein aktuelles Objekt gibt (hasAccess() == true) und
    pObject ungleich null ist, wird das aktuelle Objekt durch pObject
    ersetzt. Sonst bleibt die Liste unverändert.*/
    }

    void append(Object pObject)
    {
        if(this.isEmpty() && pObject != null)
        {
            ListenElement neu = new ListenElement();
            neu.setInhalt(pObject);
            neu.setNachfolger(schluss);
            kopf.setNachfolger(neu);
            aktuell = kopf.getNachfolger();

        }
        else if(this.hasAccess() && pObject != null)
        {
            ListenElement merke = aktuell;
            this.toLast();
            ListenElement neu = new ListenElement();
            neu.setInhalt(pObject);
            neu.setNachfolger(schluss);
            aktuell.setNachfolger(neu);
            this.toFirst();
            while(aktuell != merke)
            {
            this.next();
            }


        }

    /**Ein neues Objekt pObject wird am Ende der Liste eingefügt. Das
    aktuelle Objekt bleibt unverändert. Wenn die Liste leer ist, wird das
    Objekt pObject in die Liste eingefügt und es gibt weiterhin kein aktuelles
    Objekt (hasAccess() == false).
    Falls pObject gleich null ist, bleibt die Liste unverändert.*/
    }

    void insert(Object pObject){
        if(this.hasAccess() && pObject != null)
        {
            ListenElement lars = new ListenElement();
            ListenElement merke = aktuell;
            lars.setInhalt(pObject);
            lars.setNachfolger(aktuell);
            this.toFirst();
            while(aktuell.getNachfolger() != merke)
            {
                this.next();
            }
            aktuell.setNachfolger(lars);
            aktuell = merke;
        }
        else if(pObject != null && this.isEmpty())
        {
            /*ListenElement lückenfüller = new ListenElement();
            lückenfüller.setInhalt(pObject);
            lückenfüller.setNachfolger(schluss);
            kopf.setNachfolger(lückenfüller);*/
            this.append(pObject);
        }


    /**Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird ein
    neues Objekt vor dem aktuellen Objekt in die Liste eingefügt. Das
    aktuelle Objekt bleibt unverändert. Falls die Liste leer ist und es somit
    kein aktuelles Objekt gibt (hasAccess() == false), wird pObject
    in die Liste eingefügt und es gibt weiterhin kein aktuelles Objekt. Falls
    es kein aktuelles Objekt gibt (hasAccess() == false) und die Liste
    nicht leer ist oder pObject gleich null ist, bleibt die Liste unverändert.*/
    }

    void concat(Liste pList){
        if(pList != null && !pList.isEmpty())
        {
            ListenElement merke = aktuell;
            this.toLast();
            pList.toFirst();
            aktuell.setNachfolger(pList.aktuell);
            aktuell = kopf;
            while(aktuell != merke)
            {
                this.next();
            }
        }
    /**Die Liste pList wird an die Liste angehängt. Anschließend wird
    pList eine leere Liste. Das aktuelle Objekt bleibt unverändert. Falls
    pList null oder eine leere Liste ist, bleibt die Liste unverändert.*/
    }

    void remove()
    {
        if(this.hasAccess() && !this.isEmpty())
        {
            ListenElement merke = aktuell;
            this.toFirst();
            while(aktuell.getNachfolger() != merke)
            {
                this.next();
            }
            aktuell.setNachfolger(merke.getNachfolger());
            this.next();

        }
    /**Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das
    aktuelle Objekt gelöscht und das Objekt hinter dem gelöschten Objekt
    wird zum aktuellen Objekt. Wird das Objekt, das am Ende der Liste
    steht, gelöscht, gibt es kein aktuelles Objekt mehr (hasAccess() ==
    false). Wenn die Liste leer ist oder es kein aktuelles Objekt gibt
    (hasAccess() == false), bleibt die Liste unverändert.*/
    }

    private class ListenElement{

        private Object inhalt;
        private ListenElement folger;

        public Object getInhalt(){
            return inhalt;
        }

        public ListenElement getNachfolger(){
            return folger;
        }

        public void setInhalt(Object x){
            inhalt = x;
        }

        public void setNachfolger(ListenElement y){
            folger = y;
        }

        public void clean(){
            inhalt = null;
            folger = null;
        }
        }


}