package sequence;

import exceptions.BoundaryViolationException;
import exceptions.EmptyListException;
import exceptions.EmptySequenceException;
import exceptions.InvalidPositionException;
import iterator.IndexListIterator;
import iterator.IterablePositionIndexList;
import position.Position;
import sequence.utility.ArrayPosition;

import java.util.Iterator;

/**
 * Created with xgiovio.macbookair.
 * User: xgiovio
 * Date: 31/03/14
 * Time: 16:12
 */
public class ArraySequence<E> implements Sequence<E> {

    private Position<E>[] array;
    private int capacity = 100;
    private int size = 0;

    public ArraySequence() {
        array = new Position[capacity];
    }

    public ArraySequence(int in_size) {
        array = new Position[in_size];
        capacity = in_size;
    }


    public int size() {
        return size;
    }

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

    public E get(int r) throws IndexOutOfBoundsException {
        checkIndex(r, size());
        return array[r].element();
    }

    public E set(int r, E e) throws IndexOutOfBoundsException {
        checkIndex(r, size());
        E temp = array[r].element();
        ((ArrayPosition<E>)array[r]).setElement(e);
        return temp;
    }



    public void add(int r, E e) throws IndexOutOfBoundsException {
        checkIndex(r, size() + 1);
        if (size == capacity) {
            capacity *= 2;
            Position<E>[] B = new Position[capacity];
            for (int i=0; i<size; i++)
                B[i] = array[i];
            array = B;
        }
        for (int i=size-1; i>=r; i--)
            array[i+1] = array[i];
        array[r] = new ArrayPosition<E>(e,r);
        size++;
    }


    public E remove(int r) throws IndexOutOfBoundsException {
        checkIndex(r, size());
        E temp = array[r].element();
        for (int i=r; i<size-1; i++)
            array[i] = array[i+1];
        size--;
        return temp;
    }


    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());
            return array[in_index];
        }
        catch (IndexOutOfBoundsException err){
            throw new BoundaryViolationException();
        }
    }

    @Override
    public int indexOf(Position<E> position) throws InvalidPositionException {
        checkPosition(position);
        return ((ArrayPosition<E>) position).getIndex();
    }

    @Override
    public Position<E> first() throws EmptyListException {
        try{
            return array[0];
        }
        catch (IndexOutOfBoundsException err){
            throw new EmptyListException("Empty Array");
        }
    }

    @Override
    public Position<E> last() throws EmptyListException {
        try{
            return array[size()-1];
        }
        catch (IndexOutOfBoundsException err){
            throw new EmptyListException("Empty Array");
        }
    }


    @Override
    public Position<E> next(Position<E> p) throws InvalidPositionException, BoundaryViolationException {
        ArrayPosition<E> t = checkPosition(p);
        if (t.getIndex()< size() -1){
            return array[t.getIndex() + 1];
        }else{
            throw new BoundaryViolationException();
        }
    }

    @Override
    public Position<E> prev(Position<E> p) throws InvalidPositionException, BoundaryViolationException {
        ArrayPosition<E> t = checkPosition(p);
        if (t.getIndex()> 0){
            return array[t.getIndex() - 1];
        }else{
            throw new BoundaryViolationException();
        }
    }

    @Override
    public void addFirst(E e) {
        add (0,e);
    }

    @Override
    public void addLast(E e) {
        add (size(),e);
    }


    @Override
    public Position<E> addAfter(Position<E> p, E e) throws InvalidPositionException {
        try {
            ArrayPosition<E> t = checkPosition(p);
            add(t.getIndex() + 1, e);
            return array[t.getIndex() + 1];
        }
        catch (IndexOutOfBoundsException err){
            throw new InvalidPositionException();
        }
    }

    @Override
    public Position<E> addBefore(Position<E> p, E e) throws InvalidPositionException {
        try {
            ArrayPosition<E> t = checkPosition(p);
            add(t.getIndex() - 1,e);
            return array[t.getIndex() - 1];
        }
        catch (IndexOutOfBoundsException err){
            throw new InvalidPositionException();
        }
    }


    @Override
    public E remove(Position<E> p) throws InvalidPositionException {
        try {
            ArrayPosition<E> t = checkPosition(p);
            return remove(t.getIndex());
        }
        catch (IndexOutOfBoundsException err){
            throw new InvalidPositionException();
        }
    }

    @Override
    public E set(Position<E> p, E e) throws InvalidPositionException {
        try {
            ArrayPosition<E> t = checkPosition(p);
            return set (t.getIndex(),e);
        }
        catch (IndexOutOfBoundsException err){
            throw new InvalidPositionException();
        }


    }


    @Override
    public String toString() {

        String to_return = "";
        to_return = to_return + "[";

        for (  int i = 0; i< size() ; i++){

            if ( i== size() -1){
                to_return+=(get(i).toString());
            }else{
                to_return+=(get(i).toString() + ",");
            }
        }
        to_return = to_return + "]";

        return to_return;
    }

    protected void checkIndex(int r, int n) //
            throws IndexOutOfBoundsException {	//
        if (r < 0 || r >= n)
            throw new IndexOutOfBoundsException("Illegal index: " + r);
    }

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

        try {
            ArrayPosition<E> temp = (ArrayPosition<E>) p;
            if ( temp.getIndex() >= size() || temp.getIndex() < 0 )
                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");
        }
    }


    @Override
    ///////////////// implemented used a generic IndexListIterator
    public Iterator<E> iterator() {

        E[] temp = (E[])new Object[this.size()];
        for (int i = 0 ;i < this.size(); i++){
            temp[i] = this.get(i);
        }
        return new IndexListIterator<E>(temp);

    }

    @Override
    public Iterable<Position<E>> positions() {

        Position<E>[] temp = new Position [this.size()];
        for (int i = 0 ;i < this.size(); i++){
            temp[i] = this.atIndex(i);
        }
        return new IterablePositionIndexList<E>(temp);

    }
}