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 of any position. Negative means adding it to the end.
	 */
	@Override
	public void addAt(int pos, T elem) {
		if (root == null) {
			root = new Node(elem);
		} else if (pos == 0) {
			root = new Node(elem, root);
		} else {
			Node walker = root;
			Node prev = null;

			// If position is -1, then loop until the end of the list.
			if (pos == -1) {
				while (walker != null) {
					prev = walker;
					walker = walker.next;
				}
			// If pos is above 0, loop until it's done.
			} else if (pos > 0) {
				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.
	 */
	@Override
	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.
	 */
	@Override
	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.
	 */
	@Override
	public int size() {
		int returnValue = 0;
		Node walker = root;
		while (walker != null) {
			walker = walker.next;
			returnValue++;
		}
		return returnValue;
	}

	/**
	 * Remove all elements.
	 */
	@Override
	public void clear() {
		while (root != null) {
			Node temp = root.next;
			root = null;
			root = temp;
		}
	}

	/**
	 * Append an IList<T> to this list.
	 */
	@Override
	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.
	 */
	@Override
	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;
	}
}