package lists.doublechained;

import java.util.Iterator;

import lists.ListElem;

/**
 *
 * @author Patrick Krusch
 */
public class LinkedList<T extends Comparable<T>>{

    private ListElem<T> first;
    private ListElem<T> last;
    private int size;

    /**
     * adds a new element to the list's head
     *
     * @param data
     *            the content to add
     */
    public void addFirst(T data) {
        ListElem<T> newElem = new ListElem<T>(data);

        if (first == null){
            this.first = newElem;
            this.last = newElem;
        }
        else{
            newElem.next = first;
            first.prev = newElem;
            first = newElem;
        }
        size++;
    }

    /**
     * adds a new element to the list's tail
     *
     * @param data
     *            the content to add
     */
    public void addLast(T data) {
        ListElem<T> newElem = new ListElem<T>(data);

        if (last == null){
            this.first = newElem;
            this.last = newElem;
        }
        else{
            last.next = newElem;
            newElem.prev = last;
            last = newElem;
            }
        size++;
        }

    /**
     * returns the element located at the given position
     *
     * @param index
     *            the given position
     * @return the element contained at the given position or null if given
     *         index does not exist.
     */
    public T get(int index) {
        if (index+1 > size){
        return null;
        }
        else{
            ListElem<T> currentElement = this.first;
            for (int i=0 ; i < index; i++){
                currentElement = currentElement.next;
            }
        return currentElement.data;
        }
    }

    /**
     * removes and returns the first element of the list
     *
     * @return the first element if one exists, null otherwise
     */
    public T removeFirst() {
        if (size == 0){
            return null;
        }
        if (size == 1){
            ListElem<T> removeElement = first;
            first = null;
            last = null;
            size--;
            return removeElement.data;
        }
        else{
            ListElem<T> removeElement = first;
            this.first = removeElement.next;
            first.prev = null;
            size--;
            return removeElement.data;
        }
    }

    /**
     * removes and returns the last element of the list
     *
     * @return the last element if one exists, null otherwise
     */
    public T removeLast() {
        if (size == 0){
            return null;
        }
        if (size == 1){
            ListElem<T> removeElement = last;
            first = null;
            last = null;
            size--;
            return removeElement.data;
        }
        else{
            ListElem<T> removeElement = last;
            this.last = removeElement.prev;
            last.next = null;
            size--;
            return removeElement.data;
        }
    }


    /**
     * removes and returns the element located at the given position
     *
     * @param index
     *            the given position
     * @return the element contained at the given position or null if given
     *         index does not exist.
     */
    public T remove(int index) {
        if (index+1 > size || size==0){
            return null;
        }
        if (index == 0){
            return removeFirst();
        }
        if (index == size-1){
            return removeLast();
        }
        else{
            ListElem<T> currentElement = this.first;
            ListElem<T> prevElement = null;
            ListElem<T> nextElement = null;
            for (int i=0 ; i < index; i++){
                currentElement = currentElement.next;
            }
            prevElement = currentElement.prev;
            nextElement = currentElement.next;
            prevElement.next = nextElement;
            nextElement.prev = prevElement;
            size--;
            return currentElement.data;
        }
    }

    /**
     * @return whether this list is empty or not
     */
    public boolean isEmpty() {
        if (size == 0){
            return true;
        }
        else{
            return false;
        }
    }

    /**
     * @return the list's size
     */
    public int size() {
        return size;
    }


    public class DoubleChainIterator implements Iterable<T>, Iterator<T>{


        private int counter=-1;
        private ListElem<T> currentElement = null;


        @Override
        public boolean hasNext() {
            if (counter == -1){
                if (LinkedList.this.first != null){
                    return true;
                }
                else{
                    return false;
                }
            }
            else{
                if (currentElement.next != null){
                    return true;
                }
            }
            return false;
        }

        @Override
        public T next() {
            if (hasNext()){
                if (counter == -1){
                    currentElement = LinkedList.this.first;
                    counter++;
                    return currentElement.data;
                }
                else{
                    currentElement = currentElement.next;
                    counter++;
                    return currentElement.data;
                }
            }
            else{
                return null;
            }
        }

        @Override
        public void remove() {
            LinkedList.this.remove(counter);

        }

        @Override
        public Iterator<T> iterator() {
            return this;
        }

    }

    public static void main(String[] args) {
        LinkedList<Integer> i = new LinkedList<Integer>();
        i.addLast(1);
        i.addLast(2);
        i.addLast(3);
        Iterator<Integer> itr =  i.iterator();
        System.out.println(itr.hasNext());
        System.out.println(i.get(0) +" "+ i.get(1) +" "+ i.get(2));
        i.remove(1);
        System.out.println(i.get(0) +" "+ i.get(1));
        i.remove(0);
        System.out.println(i.get(0));
        i.remove(0);
        System.out.println(i);
    }


}