package pp;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import net.jcip.annotations.ThreadSafe;

@ThreadSafe
public class ThreadsafeSimplifiedList<T> implements SimplifiedList<T> {
	private Node<T> first;
	private final Lock listLock = new ReentrantLock();

	private class Node<U> {
		private U element;
		private Node<U> prev;
		private Node<U> next;
		private final Lock lock = new ReentrantLock();

		private Node(U element, Node<U> prev, Node<U> next) {
			super();
			this.element = element;
			this.prev = prev;
			this.next = next;
		}
	}

	public ThreadsafeSimplifiedList() {
		super();
		this.first = null;
	}

	/**
	 * Returns the element at the specified position in this list.
	 *
	 * @param index index of the element to return
	 * @return the element at the specified position in this list
	 */
	@Override
	public T get(int index) {
		this.listLock.lock();
		var ptr = this.first;
		ptr.lock.lock();
		this.listLock.unlock();
		for (var j = 0; j < index; j++) {
			if (ptr.next != null) {
				ptr.next.lock.lock();
				var savePtr = ptr;
				ptr = ptr.next;
				savePtr.lock.unlock();
			} else {
				throw new IndexOutOfBoundsException(index + " out of bounds");
			}
		}
		try {
			return (ptr.element);
		}
		finally {
			ptr.lock.unlock();
		}
	}

	/**
	 * Appends the specified element to the end of this list. There are no
	 * limitations on what elements may be added to this list.
	 * 
	 * @param element element to be appended to this list
	 * @return true
	 * @see java.util.Collection#add(Object)
	 *
	 */
	@Override
	public boolean add(T element) {
		this.listLock.lock();
		if (this.first != null) {
			var ptr = this.first;
			ptr.lock.lock();
			this.listLock.unlock();
			while (ptr.next != null) {
				ptr.next.lock.lock();
				var saveNode = ptr;
				ptr = ptr.next;
				saveNode.lock.unlock();
			}
			ptr.next = new Node<>(element, ptr, null);
		} else {
			this.first = new Node<>(element, null, null);
			this.listLock.unlock();
		}
		return true;
	}

	/**
	 * Replaces the element at the specified position in this list with the
	 * specified element.
	 * 
	 * @param index   index of the element to replace
	 * @param element element to be stored at the specified position
	 * @return the element previously at the specified position
	 */
	@Override
	public T set(int index, T element) {
		this.listLock.lock();
		var ptr = this.first;
		ptr.lock.lock();
		this.listLock.unlock();
		for (var j = 0; j < index; j++) {
			if (ptr.next != null) {
				ptr.next.lock.lock();
				var saveNode = ptr;
				ptr = ptr.next;
				saveNode.lock.unlock();
			} else {
				throw new IndexOutOfBoundsException(index + " out of bounds");
			}
		}
		var prevElement = ptr.element;
		ptr.element = element;
		ptr.lock.unlock();
		return prevElement;
	}

	/**
	 * Returns true if this list contains no elements.
	 * 
	 * @return true if this list contains no elements
	 */
	@Override
	public boolean isEmpty() {
		this.listLock.lock();
		try {
			return this.first == null;
		} finally {
			this.listLock.unlock();
		}
	}
}