#ifndef LINKEDLIST_H_
#define LINKEDLIST_H_

#include "Iterator.h"
#include "Element.h"
#include <iostream>

namespace fhdo_pk2{

template <class T>
  class LinkedList{
  private:
    element<T>* anfang;
    element<T>* ende;
    int laenge;

    //Innere Klasse--------------------------------------------------------
    class ListIterator: public Iterator<T>{

    private:
        element<T>* pointer;

    public:
        ListIterator(element<T>* anfang){
          pointer = new element<T>();
          pointer->nachfolger = anfang;
        }

        bool hasNext(){
          return (pointer->nachfolger != nullptr);
        }

         T next(){
          pointer = pointer->nachfolger;
          return pointer->inhalt;
        }
    };
    //Innere Klasse Ende---------------------------------------------------

  public:
    /* Erzeugt eine leere Liste.                                */
    LinkedList();

    /* Copy Konstruktor                                         */
    LinkedList( LinkedList& orig);

    /* Löscht die Liste                                         */
    ~LinkedList();

    /* Fuegt den Text (in konstanter Zeit) an der letzten       */
    /* Listenposition hinzu.                                    */
    /* Liefert den Wert 1, wenn das Element eingefuegt werden   */
    /* konnte. Ansonsten wird der Wert 0 geliefert.             */
    int append( T text);

    /* Fuegt ein neues Element an der Position p ein.           */
    /* Das erste Element der Liste befindet sich an der         */
    /* Position 0.                                              */
    /* Das Element, das sich aktuell an der Position p befindet,*/
    /* wird nach rechts geschoben.                              */
    /* Falls sich weniger als p Elemente in der Liste befinden, */
    /* wird der Text am Ende angefuegt.                         */
    int insert( T text, int p);

    /* Loescht das Element an der Position p. Das erste         */
    /* Element befindet sich an der Position 0.                 */
    /* Falls das p-te Element nicht existiert, wird das letzte  */
    /* Element geloescht. Die Anzahl der geloeschten Elemente   */
    /* wird als Funktionswert geliefert.                        */
    int remove(int p);

    /* Liefert den Text an der p-ten Listenposition.            */
    /* Das erste Listenelement befindet sich an der Position 0. */
    /* Falls das p-te Element nicht existiert, wird nullptr     */
    /* geliefert.*/
     T get(int p);


    /* Berechnet den Index des ersten Elements, das den Text    */
    /* text enthaelt. Falls kein Element den gesuchten Text     */
    /* enthaelt, wird -1 geliefert.                             */
    //int index_of( T text);

    /* Liefert den Text des ersten Elements der Liste (in       */
    /* konstanter Zeit).                                        */
    // T first();

    /* Liefert den Text des letzten Elements der Liste (in      */
    /* konstanter Zeit).                                        */
    // T last();


    /* Besucht alle Elemente der Liste und ruft fuer jedes      */
    /* Element die Funktion work auf.                           */
    void visit_all(void (*work)( T t));

    /* Iterator                                                 */
    Iterator<T>* iterator();

  };
}

#endif

using namespace fhdo_pk2;

template <class T>
Iterator<T>* LinkedList<T>::iterator(){
  return new ListIterator(this->anfang);
}

template <class T>
LinkedList<T>::LinkedList()
{
  anfang = nullptr;
  ende = nullptr;
  laenge = 0;
}

template <class T>
LinkedList<T>::LinkedList( LinkedList& orig) : LinkedList() {
  element<T>* p = orig.anfang;
  while(p != nullptr)
  {
    this->append(p->inhalt);
    p = p->nachfolger;
  }
}

template <class T>
LinkedList<T>::~LinkedList()
{
  int zaehler = 0;
  element<T>* az = anfang;
  element<T>* p = anfang;
  while(p != nullptr)
  {
    p = p->nachfolger;
    delete(az);
    az = p;
    zaehler++;
  }
  std::cout << "Liste gelöscht: " << zaehler << " Elemente!" << std::endl;


}

template <class T>
int LinkedList<T>::append( T text)
{
  //Neues Element erzeugen
  element<T> *neu = new element<T>();
  neu->inhalt = text;


  //wenn Liste leer
  if ((anfang == nullptr) || (ende==nullptr))
  {
    //neuen Anfang setzen
    anfang=neu;
    neu->vorgaenger = nullptr;
    neu->nachfolger = nullptr;
  }
  //wenn Liste nicht leer
  else
  {
    neu->nachfolger = nullptr;
    neu->vorgaenger = ende;
    ende->nachfolger = neu;
  }
  //in jedem Fall neues Ende setzen
  ende=neu;
  //Länge der Liste erhöhen
  laenge++;
  return 1;
}

template <class T>
int LinkedList<T>::insert( T text, int p)
{
  //SONDERFALL
  //Wenn Liste leer
  if ((anfang == nullptr) && (ende==nullptr)) return -1;
  //wenn P außerhalb der Liste bzw am Ende liegt, automatisch am Ende anhängen
  if (p<0 || p>=laenge) return append(text);
  //----------------------------------------------------------------------------

  //STANDARDFALL
  //neues Element erzeugen
  element<T> *neu = new element<T>();
  //Inhalt des neuen Elements setzen
  neu->inhalt = text;
  //Wenn am Anfang eingefügt werden soll
  if (p == 0)
  {
    neu->nachfolger = anfang;
    neu->vorgaenger = nullptr;
    anfang->vorgaenger = neu;
    anfang = neu;
  }
  //Wenn nicht am Anfang und nicht am Ende eingefügt werden soll
  else
  {
    //Zeiger auf Einfügeposition setzen
    element<T> *az = anfang;
    for(int i = 0; i<p; i++)
    {
      az = az->nachfolger;
    }
    //Zeiger entsprechend umsetzen
    neu->nachfolger =az;
    neu->vorgaenger = az->vorgaenger;
    az->vorgaenger->nachfolger=neu;
    az->vorgaenger = neu;
  }
  //Länge erhöhen
  laenge++;
  return 1;
}

template <class T>
int LinkedList<T>::remove(int p)
{
  //SONDERFALL
  //Wenn Liste leer
  if ((anfang == nullptr) && (ende==nullptr)) return -1;
  //Wenn P nicht innerhalb der Liste liegt, wird das letzte Element gelöscht
  if (p<0 || p>laenge-1) return remove(laenge-1);
  //----------------------------------------------------------------------------
  //STANDARDFALL
  //Zeiger auf Löschposition setzen
  element<T>* az = anfang;
  for(int i = 0;i<p;i++)
  {
    az = az->nachfolger;
  }
  //Wenn Ende gelöscht werden soll
  if (az == ende)
  {
    ende=az->vorgaenger;
    ende->nachfolger = nullptr;
  }
  //Wenn Anfang gelöscht werden soll
  else if (az == anfang)
  {
    anfang = anfang->nachfolger;
    anfang->vorgaenger = nullptr;
  }
  //Wenn nicht Ende und nicht Anfang gelöscht werden soll
  else
  {
    az->vorgaenger->nachfolger = az->nachfolger;
    az->nachfolger->vorgaenger = az->vorgaenger;
  }
  //Element löschen
  delete az;
  //Länge der Liste verringern
  laenge--;
  return 1;
}

template <class T>
 T LinkedList<T>::get(int p)
{
  //SONDERFALL
  //Wenn Liste leer
  if ((anfang == nullptr) && (ende==nullptr)) return nullptr;
  //Wenn P nicht innerhalb der Liste liegt
  if (p<0 || p>laenge-1) return nullptr;
  //----------------------------------------------------------------------------

  //STANDARDFALL
  //Zeiger auf Position p setzen
  element<T>* az = anfang;
  for(int i = 0;i<p;i++)
  {
    az = az->nachfolger;
  }
  //Inhalt an der Position des Zeigers zurückgeben
  return az->inhalt;
}

/*
template <class T>
int LinkedList<T>::index_of( T text)
{
  //SONDERFALL
  //Wenn Liste leer
  if ((anfang == nullptr) && (ende==nullptr)) return -1;
  //----------------------------------------------------------------------------

  //STANDARDFALL
  //Liste durchlaufen und nach "text" suchen.
  element<T>* az = anfang;
  for(int i = 0;i<laenge;i++)
  {
    //Falls "text" gefunden, Position zurückgeben
    if (az->inhalt == text) return i;
    //Zeiger einen weiter setzen.
    az = az->nachfolger;
  }
  //-1 falls in gesamter Liste "text" nicht gefunden wurde
  return -1;
}


template <class T>
 T LinkedList<T>::first()
{
  //Wenn Liste leer
  if (anfang == nullptr) return nullptr;
  //STANDARDFALL
  return anfang->inhalt;
}

template <class T>
 T LinkedList<T>::last()
{
  //Wenn Liste leer
  if (ende == nullptr) return nullptr;
  //STANDARDFALL
  return ende->inhalt;
}
*/

template <class T>
void LinkedList<T>::visit_all(void (*work)( T t))
{
  Iterator<T>* it = iterator();
  while(it->hasNext())
  {
    work(it->next());
  }
}