package position;
import  exceptions.*;
import iterator.ElementIterator;
import position.utility.DNode;

import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * Realization of a PositionList using a doubly-linked list of nodes.
 *   
 * @author Michael Goodrich, Natasha Gelfand, Roberto Tamassia, Eric Zamore
 */
//Copyright (c) 2003 Brown University, Providence, RI
//Additional modifications and methods by xgiovio

public class NodePositionList<E> implements PositionList<E> {

  protected int numElts;            	// Number of elements in the list
  protected DNode<E> header, trailer;	// Special sentinels

  public NodePositionList() {
    numElts = 0;
    header = new DNode<E>(null, null, null);	// create header
    trailer = new DNode<E>(header, null, null);	// create trailer
    header.setNext(trailer);	// make header and trailer point to each other
  }

  protected DNode<E> checkPosition(Position<E> p)  throws InvalidPositionException {
    if (p == null)
      throw new InvalidPositionException
	("Null position passed to NodeList");
    if (p == header)
	throw new InvalidPositionException
	  ("The header node is not a valid position");
    if (p == trailer)
	throw new InvalidPositionException
	  ("The trailer node is not a valid position");
    try {
      DNode<E> temp = (DNode<E>) p;
      if ((temp.getPrev() == null) || (temp.getNext() == null))
	throw new InvalidPositionException
	  ("Position does not belong to a valid NodeList");
      return temp;
    } catch (ClassCastException e) {
      throw new InvalidPositionException
	("Position is of wrong type for this list");
    }
  }

  public int size() { return numElts; }

  public boolean isEmpty() { return (numElts == 0); }

  public Position<E> first()     throws EmptyListException {
    if (isEmpty())
      throw new EmptyListException("List is empty");
    return header.getNext();
  }

  public Position<E> last()
      throws EmptyListException {
    if (isEmpty())
      throw new EmptyListException("List is empty");
    return trailer.getPrev();
  }

  public Position<E> prev(Position<E> p)        throws InvalidPositionException, BoundaryViolationException {
    DNode<E> v = checkPosition(p);
    DNode<E> prev = v.getPrev();
    if (prev == header)
      throw new BoundaryViolationException
	("Cannot advance past the beginning of the list");
    return prev;
  }

  public Position<E> next(Position<E> p)   throws InvalidPositionException, BoundaryViolationException {
    DNode<E> v = checkPosition(p);
    DNode<E> next = v.getNext();
    if (next == trailer)
      throw new BoundaryViolationException
	("Cannot advance past the end of the list");
    return next;
  }

  public Position<E> addBefore(Position<E> p, E element)         throws InvalidPositionException {
    DNode<E> v = checkPosition(p);
    numElts++;
    DNode<E> newNode = new DNode<E>(v.getPrev(), v, element);
    v.getPrev().setNext(newNode);
    v.setPrev(newNode);
    return newNode;
  }

  public Position<E> addAfter(Position<E> p, E element) throws InvalidPositionException {
    DNode<E> v = checkPosition(p);
    numElts++;
    DNode<E> newNode = new DNode<E>(v, v.getNext(), element);
    v.getNext().setPrev(newNode);
    v.setNext(newNode);
    return newNode;
  }

  public void addFirst(E element) {
    numElts++;
    DNode<E> newNode = new DNode<E>(header, header.getNext(), element);
    header.getNext().setPrev(newNode);
    header.setNext(newNode);
  }

  public void addLast(E element) {
    numElts++;
    DNode<E> oldLast = trailer.getPrev();
    DNode<E> newNode = new DNode<E>(oldLast, trailer, element);
    oldLast.setNext(newNode);
    trailer.setPrev(newNode);
  }

  public E remove(Position<E> p)
      throws InvalidPositionException {
    DNode<E> v = checkPosition(p);
    numElts--;
    DNode<E> vPrev = v.getPrev();
    DNode<E> vNext = v.getNext();
    vPrev.setNext(vNext);
    vNext.setPrev(vPrev);
    E vElem = v.element();

    v.setNext(null);
    v.setPrev(null);
    return vElem;
  }

  public E set(Position<E> p, E element)
      throws InvalidPositionException {
    DNode<E> v = checkPosition(p);
    E oldElt = v.element();
    v.setElement(element);
    return oldElt;
  }



  public boolean isFirst(Position<E> p)
    throws InvalidPositionException {  
    DNode<E> v = checkPosition(p);
    return v.getPrev() == header;
  }

  public boolean isLast(Position<E> p)
      throws InvalidPositionException {  
    DNode<E> v = checkPosition(p);
    return v.getNext() == trailer;
  }

  public void swapElements(Position<E> a, Position<E> b) 
      throws InvalidPositionException {
    DNode<E> pA = checkPosition(a);
    DNode<E> pB = checkPosition(b);
    E temp = pA.element();
    pA.setElement(pB.element());
    pB.setElement(temp);
  }


    @Override
    public String toString() {
        String to_return = "";
        to_return = to_return + "[";

        for (  DNode<E> temp = header.getNext(); temp != trailer ; temp = temp.getNext()){

            if ( temp.getNext() == trailer){
                to_return+=(temp.element().toString());
            }else{
                to_return+=(temp.element().toString() + ",");
            }
        }
        to_return = to_return + "]";

        return to_return;
    }


    public void reverse(){
          if (size() > 1){
              E temp = remove(last());
              reverse();
              addFirst(temp);
          }
    }


    @Override
    // iterator created using specific class for PositionList data structures : ElementIterator
    public Iterator<E> iterator() {
        return new ElementIterator<E>(this);
    }



    public Iterator<Position<E>> positions() {
        return new MyPositionsIterator(this);
    }

    class MyPositionsIterator implements Iterator<Position<E>>{

        public MyPositionsIterator (NodePositionList<E> structure){

            new_structure = new NodePositionList<Position<E>>();
            if (structure.size() != 0){
                Position<E> temp;
                for (temp = structure.first() ; temp!= structure.last()  ; temp = structure.next(temp)){
                    new_structure.addLast(temp);
                }
                new_structure.addLast(temp);
            }

        }

        @Override
        public boolean hasNext() {
            if (pos == null){
                if (new_structure.size() <= 0){
                    return false;
                } else {
                    return true;
                }

            } else {

                try {
                    new_structure.next(pos);
                    return true;
                }
                catch (BoundaryViolationException err){
                    return false;

                }


            }
        }

        @Override
        public Position<E> next() throws NoSuchElementException {
            if (hasNext()){
                if (pos == null){
                    pos = new_structure.first();
                }else {
                    pos = new_structure.next(pos);
                }
                return pos.element();
            } else{
                throw new NoSuchElementException();
            }
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException ();

        }

        NodePositionList<Position<E>> new_structure;
        Position<Position<E>> pos = null;


    }
}