package class7_2_TestsFixed;

import com.sun.istack.internal.NotNull;

import java.util.Collection;   // CHANGE: Added to complete interface
import java.util.ListIterator; // CHANGE: Added to complete interface
import java.util.Iterator;
import java.util.List;

/******************************************************
 *
 *                 WARNING
 *
 * This code is the code we went over in class, but
 * it does contain errors, one of which prevents it from
 * compiling.
 *
 * TODO: Test code
 *    All methods
 *    Iterator
 * ****************************************************
 */

public class LinkedList<T> implements List<T> {
    private Node head;

    public boolean add(T value) {
        Node current = head;
        Node last = null;

        while(current != null) {
            last = current;
            current = current.next;
        }

        if(null != last) {
            last.next = new Node();
            last.next.next = null;
            last.next.value = value;
        } else {
            // ERROR: Using head.next instead of head when setting head.
            head = new Node();
            head.next = null;
            head.value = value;
        }
        printList();
        return true;
    }



    private class Node {
        private Node next;
        private T value;

        private Node() {
            // do nothing;
        }

        private Node(Node next, T value) {
            this.next = next;
            this.value = value;
        }
    }

    private void printList() {
        Node current = head;
        while(current != null) {
            System.out.print(current.value+" ");
            current = current.next;
        }
        System.out.println();
    }

    @Override
    public int size() {
        Node current = head;
        int i;
        for(i=0; current != null; i++) {
            current = current.next;
        }
        return i;
    }

    @Override
    public boolean isEmpty() {
        return head == null;
    }

    @Override
    public boolean contains(Object o) {
        return locateNode(o) != null;
    }

    @Override
    public Object[] toArray() {
        int size = size();
        Object[] objects = new Object[size];
        Node current = head;
        for(int i=0; i<size; i++) {
            objects[i] = current.value;
            current = current.next;
        }
        return objects;
    }

    /**
     * Finds a node. If found, returns the node. Else, returns null
     * @param o The object which should .equal the node.
     * @return the node or null if not found.
     */
    private Node locateNode(Object o) {
        Node current = head;
        Node found = null;
        while(current != null && found == null) {
            if( (current.value == null && o == null)
               || (current.value != null && current.value.equals(o)) ) {
                found = current;
            } else {
                current = current.next;
            }
        }
        return found;
    }

    @Override
    public boolean remove(Object o) {
        // TODO: Similar to HW5, but that one is the index version.
        return false;
    }

    @Override
    public void clear() {
        head = null;
    }

    private Node getNode(int index) {
        if(index<0) {
            throw new ArrayIndexOutOfBoundsException("Cannot find element at negative index: "+index);
        }
        Node current = head;
        int i;
        for(i=0; i<index && current != null; i++) {
            current = current.next;
        }
        if(current == null) {
            throw new ArrayIndexOutOfBoundsException("Could not find element at index: "+index
                    +" size is: " + i);
        }
        return current;
    }

    @Override
    public T get(int index) {
        Node current = getNode(index);
        return current.value;
    }

    @Override
    public T set(int index, T element) {
        Node current = getNode(index);
        T previous = current.value;
        current.value = element;
        return previous;
    }

    @Override
    public void add(int index, T element) {
        // TODO: How to save time?
        if(index < 0 ) {
            throw new IndexOutOfBoundsException("Negative index!");
        } else if (index == 0) {
            head = new Node(head, element);
        } else { // index > 0
            Node current = head;

            for(int i=1; i<index;
                i++, current = current.next) {
                // do nothing
            }
            if(current != null) {
                current.next = new Node(current.next,element);
            } else {
                throw new ArrayIndexOutOfBoundsException("Index too large!");
            }
        }
    }

    @Override
    public T remove(int index) {
        // TODO: Implement for HW5.
        return null;
    }

    @Override
    public int indexOf(Object o) {
        Node current = head;
        int result = -1;
        for(int i = 0; current != null && result < 0; i++, current = current.next) {
            if(o == null && current.value == null
                    || o != null && o.equals(current.value)) {
                result = i;
            }
        }
        return result;
    }

    @Override
    @NotNull
    public List<T> subList(int fromIndex, int toIndex) {
        // TODO: Potential HW
        return null;  //To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
    @NotNull
    public Iterator<T> iterator() {
        return new MyIterator();
    }

    private class MyIterator implements Iterator<T> {

        Node next;
        Node current;
        Node prev;

        private MyIterator() {
            next = head;
            current = null;
            prev = null;
        }

        @Override
        public boolean hasNext() {
            return next != null;
        }

        @Override
        public T next() {
            prev = current;
            current = next;
            next = next.next;
            return current.value;
        }

        @Override
        public void remove() {
            if(prev != null) {
                prev.next = next;
            } else {
                head = next;
            }
        }
    }

    // CHANGE: Added to complete the interface

    @Override
    public <T1> T1[] toArray(T1[] a) {
        throw new UnsupportedOperationException("This operation not supported");
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        throw new UnsupportedOperationException("This method not implemented");
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        throw new UnsupportedOperationException("This method not implemented");
    }

    @Override
    public boolean addAll(int index, Collection<? extends T> c) {
        throw new UnsupportedOperationException("This method not implemented");
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        throw new UnsupportedOperationException("This method not implemented");
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        throw new UnsupportedOperationException("This method not implemented");
    }

    @Override
    public int lastIndexOf(Object o) {
        throw new UnsupportedOperationException("This method not implemented");
    }

    @Override
    public ListIterator<T> listIterator() {
        throw new UnsupportedOperationException("This method not implemented");
    }

    @Override
    public ListIterator<T> listIterator(int index) {
        throw new UnsupportedOperationException("This method not implemented");
    }
}