package io.dama.par.hoh;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;


public class ThreadsafeSimplifiedList<T> implements SimplifiedList<T> {

    private class Node<U> {
        ReadWriteLock lock;
        Lock readLock;
        Lock writeLock;

        private U element;
        private Node<U> prev;
        private Node<U> next;

        private Node(final U element, final Node<U> prev, final Node<U> next) {
            super();
            lock = new ReentrantReadWriteLock();
            readLock = lock.readLock();
            writeLock = lock.writeLock();
            this.element = element;
            this.prev = prev;
            this.next = next;
        }
    }

    private Node<T> first;

    @Override
    public T get(int index) {

        this.first.readLock.lock();
        Node<T> ptr = this.first;
        for (int j = 0; j < index; j++) {
            ptr.next.readLock.lock();
            ptr = ptr.next;
            ptr.prev.readLock.unlock();
        }
        return delay(ptr.element);
    }

    @Override
    public boolean add(T element) {

         if(this.first == null) {
            this.first = new Node<>(element, null, null);
         }
         else {
             this.first.readLock.lock();
             Node<T> ptr = this.first;
             this.first.readLock.unlock();
             if(ptr.next != null)
                 ptr.next.readLock.lock();
             while (ptr.next != null) {
                 ptr.next.readLock.lock();
                 ptr = ptr.next;
                 ptr.readLock.unlock();
             }
             if(ptr.next == null) {
                 ptr.next = new Node<>(element, ptr, null);
             }
        }
        return true;
    }

    @Override
    public T set(int index, T element) {

        if(index == 1) {
            this.first.readLock.lock();
            Node<T> new2nd = this.first;
            this.first.readLock.unlock();

            this.first.writeLock.lock();
            this.first = new Node<T>(element, null, new2nd);
            new2nd.prev = this.first;
            new2nd.writeLock.unlock();
        }
        else {
            this.first.readLock.lock();
            Node<T> ptr = this.first;
            for (int j = 1; j < index; j++) {
                ptr.next.readLock.lock();
                ptr = ptr.next;
                ptr.prev.readLock.unlock();
            }

            ptr.prev.readLock.lock();
            Node<T> newNode = new Node<>(element, ptr.prev, ptr);
            ptr.readLock.unlock();
            Node<T> ptrPrev = ptr.prev;
            ptr.prev.readLock.unlock();

            ptr.writeLock.lock();
            ptr.prev = newNode;
            ptr.writeLock.unlock();

            ptrPrev.writeLock.lock();
            ptrPrev.next = newNode;
            ptrPrev.writeLock.unlock();
        }

        return element;
    }

    @Override
    public boolean isEmpty() {
        try {
            this.first.readLock.lock();
            return this.first == null;
        } finally {
            this.first.readLock.unlock();
        }
    }

}