public class List<T> implements IList<T> {

	/**
	 * Node for handling the list.
	 */
	private class Node {
		private T item;
		private Node next;
		
		public Node(T item, Node next) {
			this.item = item;
			this.next = next;
		}
		
		public Node(T item) {
			this.item = item;
			this.next = null;
		}
	}
	
	/**
	 * Contains the root node.
	 */
	private Node root;
	
	/**
	 * Add an element at a specific position starting at 0.
	 */
	public void addAt(int pos, T elem) {
		if (root == null) {
			root = new Node(elem);
		} else if (pos == 0) {
			root = new Node(elem, root);
		} else if (pos > 0) {
			Node walker = root;
			Node prev = null;
			
			while (walker != null && pos > 0) {
				pos--;
				prev = walker;
				walker = walker.next;
			}
			
			walker = new Node(elem, walker);
			prev.next = walker;			
		}
	}
	
	/**
	 * Remove an element at a position.
	 */
	public boolean removeAt(int pos) {
		boolean isRemoved = false;
		if (root != null) {
			if (pos == 0) {
				root = root.next;
				isRemoved = true;
			} else if (pos > 0 && pos < size()) {
				Node walker = root;
				Node prev = null;
				
				while (walker != null && pos > 0) {
					pos--;
					prev = walker;
					walker = walker.next;
				}
				
				prev.next = walker.next;
				walker = null;
				isRemoved = true;
			}
		}
		return isRemoved;
	}
	
	/**
	 * Find an item in the list of type T.
	 */
	public int find(T elem) {
		int returnValue = 0;
		
		Node walker = root;
		while (walker != null && walker.item != elem) {
			walker = walker.next;
			returnValue++;
		}
		
		if (walker == null) {
			returnValue = -1;
		}
		
		return returnValue;
	}
	
	/**
	 * Return the current size of the list.
	 */
	public int size() {
		int returnValue = 0;
		Node walker = root;
		while (walker != null) {
			walker = walker.next;
			returnValue++;
		}
		return returnValue;
	}
	
	/**
	 * Remove all elements.
	 */
	public void clear() {
		while (root != null) {
			Node temp = root.next;
			root = null;
			root = temp;
		}
	}
	
	/**
	 * Append an IList<T> to this list.
	 */
	public void append(IList<T> aList) {
		@SuppressWarnings("unchecked")
		T[] elements = (T[]) aList.getAllElementsAsStrings();
		int size = size();
		
		for (T element : elements) {
			addAt(size++, element);
		}
	}
	
	/**
	 * Returns an array of strings with all elements.
	 */
	public String[] getAllElementsAsStrings() {
		int size = size();
		String[] list = new String[size];
		
		Node walker = root;
		for (int i = 0; i < size; ++i) {
			list[i] = (String)walker.item;
			walker = walker.next;
		}
		
		return list;
	}
}