package sequence;

import arraylist.ArrayIndexList;
import exceptions.BoundaryViolationException;
import exceptions.EmptyListException;
import exceptions.EmptySequenceException;
import exceptions.InvalidPositionException;
import position.Position;
import sequence.utility.DNodeIndex;

/**
 * Created with MONSTER.
 * User: xgiovio
 * Date: 30/03/2014
 * Time: 17:19
 */
public class ArraySequence<E> extends ArrayIndexList<E> implements Sequence<E> {

    @Override
    public E getFirst() throws EmptySequenceException {
        try {
            E ele = get(0);
            return ele;
        }
        catch (IndexOutOfBoundsException err){
            throw new EmptySequenceException();
        }
    }

    @Override
    public E getLast() throws EmptySequenceException {
        try {
            E ele = get(size()-1);
            return ele;
        }
        catch (IndexOutOfBoundsException err){
            throw new EmptySequenceException();
        }
    }

    @Override
    public E removeFirst() throws EmptySequenceException {
        try {
            E ele = remove(0);
            return ele;
        }
        catch (IndexOutOfBoundsException err){
            throw new EmptySequenceException();
        }
    }

    @Override
    public E removeLast() throws EmptySequenceException {
        try {
            E ele = remove(size() - 1);
            return ele;
        }
        catch (IndexOutOfBoundsException err){
            throw new EmptySequenceException();
        }
    }

    @Override
    public Position<E> atIndex(int in_index) throws BoundaryViolationException {
        try {
            checkIndex(in_index, size());

            /////////////


        }
        catch (IndexOutOfBoundsException err){
            throw new BoundaryViolationException();
        }


    }

    @Override
    public int indexOf(Position<E> position) throws InvalidPositionException {
        return 0;
    }

    @Override
    public Position<E> first() throws EmptyListException {
        return null;
    }

    @Override
    public Position<E> last() throws EmptyListException {
        return null;
    }

    @Override
    public Position<E> next(Position<E> p) throws InvalidPositionException, BoundaryViolationException {
        return null;
    }

    @Override
    public Position<E> prev(Position<E> p) throws InvalidPositionException, BoundaryViolationException {
        return null;
    }

    @Override
    public void addFirst(E e) {

    }

    @Override
    public void addLast(E e) {

    }

    @Override
    public void addAfter(Position<E> p, E e) throws InvalidPositionException {

    }

    @Override
    public void addBefore(Position<E> p, E e) throws InvalidPositionException {

    }

    @Override
    public E remove(Position<E> p) throws InvalidPositionException {
        return null;
    }

    @Override
    public E set(Position<E> p, E e) throws InvalidPositionException {
        return null;
    }

    @Override
    public String toString() {
        return super.toString();
    }

    protected DNodeIndex<E> checkPosition(Position<E> p)  throws InvalidPositionException {
        if (p == null)
            throw new InvalidPositionException
                    ("Null position passed");

        try {
            DNodeIndex<E> temp = (DNodeIndex<E>) p;
            if ((temp.getPrev() == null) || (temp.getNext() == null) || (temp.getIndex() == -1))
                throw new InvalidPositionException
                        ("Position does not belong to a valid value");
            return temp;
        } catch (ClassCastException e) {
            throw new InvalidPositionException
                    ("Position is of wrong type for this array");
        }
    }
}