package class4_1_LinkedList_tests_start;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class LinkedList<E> implements List<E> {
    private Node head = null;
    private Node tail = null;
    private int size = 0;

    private class Node {
        private E value;
        private Node next;

        public Node(E value, Node next) {
            this.value = value;
            this.next = next;
        }
    }

    public boolean add(E element) {
        return add2(element);
    }

    // Original version using the approach we used in class
    public boolean add1(E element) {
        Node newNode = new Node(element, null);
        if(size == 0){
            head = newNode;
        } else {
            Node current = head;
            while(current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
        tail = newNode;
        size++;
        return true;
    }

    // New version to take advantage of the tail
    public boolean add2(E element) {
        Node newNode = new Node(element, null);
        if(size == 0){
            head = newNode;
        } else {
            tail.next = newNode;
        }
        tail = newNode;
        size++;
        return true;
    }

    // based on version from Section 051
    public void add(int index, E element) {
        if(index < 0 || index > size) { // FIXED BUG: Must allow index == size for elements
                                        // inserted at the end.
            throw new IndexOutOfBoundsException("index cannot be negative. It is: " + index);
        } if(index == 0) {
            head = new Node(element, head);
            if(tail == null) {
                tail = head;
            }
        } else {
            Node current = head;
            for(int i = 0; i<index-1;i++) {
                current = current.next;
            }
            current.next = new Node(element, current.next);
            if(tail == current) {
                tail = current.next;
            }
        }
        size++;
    }
    @Override
    public E remove(int index) {
        throw new UnsupportedOperationException("Method not yet implemented.");
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public boolean remove(Object o) {
        throw new UnsupportedOperationException("Method not yet implemented.");
    }

    @Override
    public E set(int index, E element) {
        throw new UnsupportedOperationException("Method not yet implemented.");
    }

    @Override
    public int size() {
        // No more broken-box testing while doing more extensive unit tests...
        return size;
    }

    @Override
    public boolean isEmpty() {
        throw new UnsupportedOperationException("Method not yet implemented.");
    }

    @Override
    public boolean contains(Object o) {
        throw new UnsupportedOperationException("Method not yet implemented.");
    }

    @Override
    public Object[] toArray() {
        throw new UnsupportedOperationException("Method not yet implemented.");
    }

    // Methods beyond this point will not be implemented in CS2852
    @Override
    public Iterator<E> iterator() {
        return new Iter();
    }

    private class Iter implements Iterator<E> {
        private Node current = head;

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

        @Override
        public E next() {
            E tmp = current.value;
            current = current.next;
            return tmp;
        }
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<E> listIterator() {
        return null;
    }

    @Override
    public ListIterator<E> listIterator(int index) {
        return null;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        return null;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public E get(int index) {
        return null;
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }

}