package msqueue;

import java.util.NoSuchElementException;
import java.util.concurrent.atomic.AtomicReference;

public class MSQueue implements Queue {
    /*private Node head;
    private Node tail;
    */
    private AtomicReference<Node> head;
    private AtomicReference<Node> tail;

    public MSQueue() {
        Node dummy = new Node(0, null);
        //this.head = dummy;
        //this.tail = dummy;
        head = new AtomicReference<>(dummy);
        tail = new AtomicReference<>(dummy);
    }

    @Override
    public void enqueue(int x) {
        /*
        Node newTail = new Node(x);
        tail.next = newTail;
        tail = newTail;
        */
        Node newNode = new Node(x);
        newNode.next = new AtomicReference<>(null);
        while (true) {
            Node currentTail = tail.get();
            newNode.next = new AtomicReference<>(currentTail);
            if (currentTail.next.get() == null) {
                if (tail.get().next.compareAndSet(currentTail.next.get(), newNode)) {
                    break;
                }
            } else {
                tail.compareAndSet(currentTail, currentTail.next.get());
            }
        }
    }

    @Override
    public int dequeue() {
        /*Node curHead = head;
        Node next = head.next;
        if (curHead == tail)
            throw new NoSuchElementException();
        head = next;
        return next.x;*/
        while (true) {
            Node currentTail = tail.get();
            Node currentHead = head.get();
            Node next = currentHead.next.get();
            if (currentHead == currentTail) {
                if (next == null) {
                    throw new NoSuchElementException();
                }
                tail.compareAndSet(currentTail, next);
            } else {
                int result = next.x;
                if (head.compareAndSet(currentHead, next)) {
                    return result;
                }
            }
        }

    }

    @Override
    public int peek() {
        /*Node curHead = head;
        Node next = head.next;
        if (curHead == tail)
            throw new NoSuchElementException();
        return next.x;*/
        /*Node currentHead = head.get();
        Node current*/
        while (true) {
            Node currentTail = tail.get();
            Node currentHead = head.get();
            Node next = currentHead.next.get();
            if (currentHead == currentTail) {
                if (next == null) {
                    throw new NoSuchElementException();
                }
                tail.compareAndSet(currentTail, next);
            } else {
                //int result = next.x;
                return next.x;
            }
        }
    }

    private class Node {
        final int x;
        AtomicReference<Node> next;

        Node(int x) {
            this.x = x;
        }

        Node(int x, Node next) {
            this.x = x;
            this.next = new AtomicReference<>(next);
        }
    }
}