package ads;

import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.logging.Level;
import java.util.logging.Logger;

public class AbstrDoubleList<T>
  implements IAbstrDoubleList<T>
{
  private AbstrDoubleList<T>.Node _prvni;
  private AbstrDoubleList<T>.Node _posledni;
  private AbstrDoubleList<T>.Node _aktualni;

  private class Node
  {
    private AbstrDoubleList<T>.Node _predchozi;
    private AbstrDoubleList<T>.Node _nasledujici;
    private T _data;

    public Node()
    {
      this._data = _data;
      this._predchozi = null;
      this._nasledujici = null;
    }

    public Node(AbstrDoubleList<T>.Node _predchozi, T _nasledujici)
    {
      this._predchozi = _predchozi;
      this._nasledujici = _nasledujici;
      this._data = _data;
    }

    public AbstrDoubleList<T>.Node getPredchozi()
    {
      return this._predchozi;
    }

    public void setPredchozi(AbstrDoubleList<T>.Node _predchozi)
    {
      this._predchozi = _predchozi;
    }

    public AbstrDoubleList<T>.Node getNasledujici()
    {
      return this._nasledujici;
    }

    public void setNasledujici(AbstrDoubleList<T>.Node _nasledujici)
    {
      this._nasledujici = _nasledujici;
    }

    public T getData()
    {
      return this._data;
    }

    public void setData(T _data)
    {
      this._data = _data;
    }
  }

  private void testPrazdny()
    throws NoSuchElementException
  {
    if (jePrazdny()) {
      throw new NoSuchElementException();
    }
  }

  private void testAktualni()
    throws NoSuchElementException
  {
    if (this._aktualni == null) {
      throw new NoSuchElementException();
    }
  }

  private void testData(T data)
    throws NullPointerException
  {
    if (data == null) {
      throw new NullPointerException();
    }
  }

  private boolean isAktualniPrvni()
  {
    return this._aktualni == this._prvni;
  }

  private boolean isAktualniPosledni()
  {
    return this._aktualni == this._posledni;
  }

  public void zrus()
  {
    if (!jePrazdny())
    {
      AbstrDoubleList<T>.Node temp = this._prvni;
      while (temp != null)
      {
        temp = temp.getNasledujici();
        this._prvni = null;
        this._prvni = temp;
      }
      this._prvni = (this._posledni = this._aktualni = null);
    }
  }

  public boolean jePrazdny()
  {
    return this._prvni == null;
  }

  public void vlozPrvni(T prvek)
    throws NullPointerException
  {
    testData(prvek);

    AbstrDoubleList<T>.Node temp = new Node(prvek);
    if (jePrazdny())
    {
      this._prvni = temp;
      this._posledni = temp;
    }
    else
    {
      this._prvni.setPredchozi(temp);
      temp.setNasledujici(this._prvni);
      this._prvni = temp;
    }
  }

  public void vlozPosledni(T prvek)
    throws NullPointerException
  {
    testData(prvek);
    if (jePrazdny())
    {
      vlozPrvni(prvek);
    }
    else
    {
      AbstrDoubleList<T>.Node temp = new Node(prvek);
      temp.setPredchozi(this._posledni);
      this._posledni.setNasledujici(temp);
      this._posledni = temp;
    }
  }

  public void vlozNaslednika(T prvek)
    throws NullPointerException, NoSuchElementException
  {
    testData(prvek);
    testAktualni();
    testPrazdny();
    if (isAktualniPosledni())
    {
      vlozPosledni(prvek);
    }
    else
    {
      AbstrDoubleList<T>.Node temp = new Node(this._aktualni, this._aktualni.getNasledujici(), prvek);
      this._aktualni.getNasledujici().setPredchozi(temp);
      this._aktualni.setNasledujici(temp);
    }
  }

  public void vlozPredchudce(T prvek)
    throws NullPointerException, NoSuchElementException
  {
    testData(prvek);
    testAktualni();
    testPrazdny();
    if (isAktualniPrvni())
    {
      vlozPrvni(prvek);
    }
    else
    {
      AbstrDoubleList<T>.Node temp = new Node(this._aktualni.getPredchozi(), this._aktualni, prvek);
      this._aktualni.getPredchozi().setNasledujici(temp);
      this._aktualni.setPredchozi(temp);
    }
  }

  public T zpristupniAktualni()
    throws NoSuchElementException
  {
    testAktualni();
    testPrazdny();

    return this._aktualni.getData();
  }

  public T zpristupniPrvni()
    throws NoSuchElementException
  {
    testPrazdny();

    this._aktualni = this._prvni;
    return this._aktualni.getData();
  }

  public T zpristupniPosledni()
    throws NoSuchElementException
  {
    testPrazdny();

    this._aktualni = this._posledni;
    return this._aktualni.getData();
  }

  public T zpristupniNaslednika()
    throws NoSuchElementException
  {
    testPrazdny();
    testAktualni();
    if (this._aktualni.getNasledujici() == null) {
      throw new NoSuchElementException();
    }
    this._aktualni = this._aktualni.getNasledujici();
    return this._aktualni.getData();
  }

  public T zpristupniPredchudce()
    throws NoSuchElementException
  {
    testPrazdny();
    testAktualni();
    if (this._aktualni.getPredchozi() == null) {
      throw new NoSuchElementException();
    }
    this._aktualni = this._aktualni.getPredchozi();
    return this._aktualni.getData();
  }

  public T odeberAktualni()
    throws NoSuchElementException
  {
    testPrazdny();
    testAktualni();
    T retData;
    T retData;
    if (isAktualniPrvni())
    {
      retData = odeberPrvni();
    }
    else
    {
      T retData;
      if (isAktualniPosledni())
      {
        retData = odeberPosledni();
      }
      else
      {
        retData = this._aktualni.getData();
        this._aktualni.getPredchozi().setNasledujici(this._aktualni.getNasledujici());
        this._aktualni.getNasledujici().setPredchozi(this._aktualni.getPredchozi());
        this._aktualni = null;
      }
    }
    this._aktualni = this._prvni;
    return retData;
  }

  public T odeberPrvni()
    throws NoSuchElementException
  {
    testPrazdny();
    T retData;
    if (this._prvni == this._posledni)
    {
      T retData = this._prvni.getData();
      zrus();
    }
    else
    {
      retData = this._prvni.getData();
      this._prvni.getNasledujici().setPredchozi(null);
      this._prvni = this._prvni.getNasledujici();
    }
    return retData;
  }

  public T odeberPosledni()
    throws NoSuchElementException
  {
    testPrazdny();
    T retData;
    T retData;
    if (this._prvni == this._posledni)
    {
      retData = odeberPrvni();
    }
    else
    {
      retData = this._posledni.getData();
      this._posledni.getPredchozi().setNasledujici(null);
      this._posledni = this._posledni.getPredchozi();
    }
    return retData;
  }

  public T odeberNaslednika()
    throws NoSuchElementException, NullPointerException
  {
    testPrazdny();
    testAktualni();
    if (isAktualniPosledni()) {
      throw new NoSuchElementException();
    }
    T retData;
    T retData;
    if (this._aktualni == this._posledni.getPredchozi())
    {
      retData = odeberPosledni();
    }
    else
    {
      retData = this._aktualni.getNasledujici().getData();

      this._aktualni.getNasledujici().getNasledujici().setPredchozi(this._aktualni);
      this._aktualni.setNasledujici(this._aktualni.getNasledujici().getNasledujici());
    }
    return retData;
  }

  public T odeberPredchudce()
    throws NoSuchElementException, NullPointerException
  {
    testPrazdny();
    testAktualni();
    if (isAktualniPrvni()) {
      throw new NoSuchElementException();
    }
    T retData;
    T retData;
    if (this._aktualni == this._prvni.getNasledujici())
    {
      retData = odeberPrvni();
    }
    else
    {
      retData = this._aktualni.getPredchozi().getData();

      this._aktualni.getPredchozi().getPredchozi().setNasledujici(this._aktualni);
      this._aktualni.setPredchozi(this._aktualni.getPredchozi().getPredchozi());
      return retData;
    }
    return retData;
  }

  public Iterator<T> iterator()
  {
    new Iterator()
    {
      private AbstrDoubleList<T>.Node akt = AbstrDoubleList.this._prvni;
      private T pom = null;
      private boolean opak = false;
      private boolean empty = false;

      public boolean hasNext()
      {
        if (!AbstrDoubleList.this.jePrazdny())
        {
          if (this.empty) {
            return false;
          }
          return (this.akt != AbstrDoubleList.this._prvni) || (this.opak != true);
        }
        return false;
      }

      public T next()
      {
        if (hasNext())
        {
          this.opak = true;
          this.pom = this.akt._data;
          if (this.akt._nasledujici != null) {
            this.akt = this.akt._nasledujici;
          } else {
            this.empty = true;
          }
          return this.pom;
        }
        throw new NoSuchElementException("no more elements");
      }

      public void remove()
      {
        try
        {
          AbstrDoubleList.this.odeberAktualni();
        }
        catch (Exception ex)
        {
          Logger.getLogger(AbstrDoubleList.class.getName()).log(Level.SEVERE, null, ex);
        }
      }
    };
  }
}