import java.util.NoSuchElementException;

// A LinkedList object represents an ordered list of linked nodes.
public class LinkedList<E> extends AbstractList<E> implements Queue<E> {
	private ListNode<E> front;

	// Constructs an empty list.
	public LinkedList() {
		front = null;
	}
	
	// Adds a value at a given index.
	// pre: 0 <= index <= size
	// Throws a NullPointerException if index > size.
	public boolean add(int index, E value) {
		if (index == 0) {
			front = new ListNode<E>(value, front);
		} else {
			ListNode<E> current = front;
			for (int i = 0; i < index - 1; i++) {
				current = current.next;
			}
			ListNode<E> temp = new ListNode<E>(value, current.next);
			current.next = temp;
			// also ok: current.next = new ListNode(value, current.next);
		}
		return true;
	}

	// Sets the given index to store the given value.
	// pre: 0 <= index < size, throws ArrayIndexOutOfBoundsException otherwise
	public void set(int index, E value) {
		if (index < 0 || index >= size()) {
			throw new ArrayIndexOutOfBoundsException();
		}
		ListNode<E> current = front;
		for (int i = 0; i < index; i++) {
			current = current.next;
		}
		current.data = value;
	}

	// Returns the value at a given index
	// pre: 0 <= index < number of nodes; front != null
	// throws NullPointerException if index > size.
	public E get(int index) {
		ListNode<E> current = front;
		for (int i = 0; i < index; i++) {
			current = current.next;
		}
		return current.data;
	}

	// Removes the value at the given index.
	// Pre: 0 <= index < size
	// Throws a NullPointerException if index > size.
	public E remove(int index) {
		if (index == 0) {
			E element = front.data;
			front = front.next;
			return element;
		} else {
			ListNode<E> current = front;
			for (int i = 0; i < index - 1; i++) {
				current = current.next;
			}
			E element = current.next.data;
			current.next = current.next.next;
			return element;
		}
	}

	// Removes the given value if it is contained in this list
	// Pre: value != null
	// Throws a NullPointerException if index > size.
	public boolean remove(E value) {
		if (front == null) {
			return false;
		}
		if (front.data.equals(value)) {
			front = front.next;
			return true;
		} else {
			ListNode<E> current = front;
			while (current.next != null) {
				if (current.next.data.equals(value)) {
					current.next = current.next.next;
					return true;
				}
				current = current.next;
			}
			return false;
		}
	}

	// Removes and returns the element at the front of this list
	// Throws a NoSuchElementException if this list is empty.
	public E remove() {
		if (isEmpty()) {
			throw new NoSuchElementException();
		}
		return remove(0);
	}

	// Returns the element on the front of this list.
	// Throws a NoSuchElementException if the list is empty.
	public E peek() {
		if (isEmpty()) {
			throw new NoSuchElementException();
		}
		return get(0);
	}

	// Returns the index of the first occurrence of the given value in the list,
	// or -1 if the value is not found in the list.
	public int indexOf(E value) {
		int index = 0;
		ListNode<E> current = front;
		while (current != null) {
			if (current.data.equals(value)) {
				return index;
			}
			index++;
			current = current.next;
		}
		return -1;
	}

	// Returns the size of this list (inefficient -- could use a size field).
	public int size() {
		ListNode<E> current = front;
		int count = 0;
		while (current != null) {
			current = current.next;
			count++;
		}
		return count;
	}

	// Returns a comma-separated String representation of this list.
	public String toString() {
		if (front == null) {
			return "[]";
		} else {
			String result = "[" + front.data;
			ListNode current = front.next;
			while (current != null) {
				result += ", " + current.data;
				current = current.next;
			}
			result += "]";
			return result;
		}
	}
	
	// A ListNode represents a single node in a linked list. It stores an
	// integer
	// value and a link to the next node.
	private static class ListNode<E> {
		// LinkedList.this
	    private E data;
	    private ListNode<E> next;

	    // Creates a ListNode with the specified integer data and next node.
	    public ListNode(E data, ListNode next) {
	        this.data = data;
	        this.next = next;
	    }
	}

}