// Java Program to implement DelayQueue API

// Importing classes from
// java.util package
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

// Class
public class DelayQueueImpl<E extends Delayed> {
    private DelayQueue<E> delayQueue;

    // Method 1
    public DelayQueueImpl()
    {
        // Step 1: Create a new DelayQueue
        // that is initially empty
        delayQueue = new DelayQueue<E>();
    }

    // Method 2 - Creating delayQueue
    // for containing elements
    public DelayQueueImpl(Collection<? extends E> c)
    {

        // Step 2: Creates a DelayQueue initially containing
        // elements of collection of Delayed instances
        delayQueue = new DelayQueue<>(c);
    }

    // Method 3
    // Step 3: Inserts the specified element
    // into this delay queue
    public boolean add(E e) { return delayQueue.add(e); }

    // Method 4
    public void clear()
    {
        // Automatically removes all of the elements
        // from this queue
        delayQueue.clear();
    }

    // Method 5
    public boolean contains(Object o)
    {
        // Returns true if this queue contains the specified
        // element else return false
        return delayQueue.contains(o);
    }

    // Method 6
    public int drainTo(Collection<? super E> c)
    {
        // Step 4: Removes all available elements from this
        // queue and adds them to the given collection.
        return delayQueue.drainTo(c);
    }

    // Method 7
    // Step 5: Removes at most the given number of available
    // elements from queue and adds them to the given
    // collection
    public int drainTo(Collection<? super E> c,
                       int maxElements)
    {
        return delayQueue.drainTo(c, maxElements);
    }

    // Method 8
    public Iterator<E> iterator()
    {
        // Returns an iterator over the elements
        // in this queue in proper sequence
        return delayQueue.iterator();
    }

    // Method 9
    // Step 6: Inserts the specified element at the tail of
    // this queue if possible to do so immediately without
    // exceeding the queue's capacity

    // Method 10
    public boolean offer(E e)
    {
        // Return true upon success and false
        // if this queue is full else return false
        return delayQueue.offer(e);
    }

    // Step 7: Inserts the specified element into delay
    // queue
    public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException
    {
        return delayQueue.offer(e, timeout, unit);
    }

    // Method 11
    // Step 8: Retrieve but does not remove the head
    // of this queue
    public E peek()
    {
        // Or simply returns null if this queue is empty
        return delayQueue.peek();
    }

    // Step 8(a): Retrieves and removes the head of this
    // queue
    public E poll()
    {

        // Or simply returns null if this queue is empty.
        return delayQueue.poll();
    }

    // Step 8(b): Retrieves and removes the head of queue
    // waiting if necessary untilan element with an
    // expired delay is available on this queue
    public E poll(long timeout, TimeUnit unit)
        throws InterruptedException
    {
        return delayQueue.poll(timeout, unit);
    }

    // Method 12
    // Step 9: Insert the specified element into delay queue
    public void put(E e) throws InterruptedException
    {
        delayQueue.put(e);
    }

    // Method 13
    public int remainingCapacity()
    {
        // Remember : Always returns Integer.MAX_VALUE
        // because a DelayQueue is not capacity constrained
        return delayQueue.remainingCapacity();
    }

    // Step 10: Removes a single instance of the specified
    // element from this queue, if it is present
    public boolean remove(Object o)
    {
        return delayQueue.remove(o);
    }
    public int size() { 
      return delayQueue.size();
    }
    // Retrieves and removes the head of this queue, waiting
    // if necessary until an element with an expired delay
    // is available on this queue.

    public E take() throws InterruptedException
    {
        // Returns an array containing all of the elements
        // in
        // this queue, in proper sequence.
        return delayQueue.take();
    }

    public Object[] toArray()
    {
        // Returns an array containing all elements in queue

        return delayQueue.toArray();
    }

    // The runtime type of the returned array is
    // that of the specified array
    public <T> T[] toArray(T[] a)
    {
        return delayQueue.toArray(a);
    }

    // Class
    static class DelayObjects implements Delayed {
        // Member variable of class
        public long time;

        // Member function of class
        public DelayObjects()
        {
            getDelay(TimeUnit.MILLISECONDS);
        }

        // Overriding using compareTo() method
        @Override public int compareTo(Delayed o)
        {
            if (this.time < ((DelayObjects)o).time)
                return -1;
            else if (this.time > ((DelayObjects)o).time)
                return 1;
            return 0;
        }

        @Override public long getDelay(TimeUnit unit)
        {
            time = System.currentTimeMillis();
            return time;
        }
    }

    // Main driver method
    public static void main(String[] args)
        throws InterruptedException
    {
        // Creating object of class- DelayQueueImpl
        DelayQueueImpl<DelayObjects> arrayBlockingQueue
            = new DelayQueueImpl<DelayObjects>();

        // Adding custom inputs
        DelayObjects delayObject1 = new DelayObjects();
        Thread.sleep(100);
        DelayObjects delayObject2 = new DelayObjects();
        Thread.sleep(100);
        DelayObjects delayObject3 = new DelayObjects();
        Thread.sleep(100);
        DelayObjects delayObject4 = new DelayObjects();
        Thread.sleep(100);
        DelayObjects delayObject5 = new DelayObjects();

        // Try block to check exceptions
        try {
            arrayBlockingQueue.put(delayObject1);
            arrayBlockingQueue.put(delayObject2);
            arrayBlockingQueue.put(delayObject3);
        }

        // Catch block to handle exceptions if occurs
        catch (InterruptedException e) {
            // Print the line number where exception occurred
            e.printStackTrace();
        }

        // Adding objects to above queue
        arrayBlockingQueue.add(delayObject4);
        arrayBlockingQueue.add(delayObject5);

        // Display message
        System.out.print(
            "Delaytimes of the DelayQueue is           : ");

        // iterator to traverse over collection
        Iterator<DelayObjects> itr
            = arrayBlockingQueue.iterator();

        // Condition check using hasNext()
        while (itr.hasNext()) {
            // Print elements
            System.out.print(itr.next().time + "\t");
        }

        // New line
        System.out.println();

        // Using offer() method over objects
        arrayBlockingQueue.offer(new DelayObjects());
        arrayBlockingQueue.offer(new DelayObjects());

        // Print and Display messages to showcase
        // implementation of DelayQueue API
        System.out.println(
            "Element time of the DelayQueue by peeking :  "
            + arrayBlockingQueue.peek().time);

        System.out.println(
            "Remaining capacity                         : "
            + arrayBlockingQueue.remainingCapacity());

        System.out.println(
            "DelayObject1 removed ?                    : "
            + arrayBlockingQueue.remove(delayObject1));

        System.out.println(
            "DelayQueue contains DelayObject2 ?        : "
            + arrayBlockingQueue.contains(delayObject2));

        System.out.println(
            "hash DelayQueue contains DelayObject3 ?   : "
            + arrayBlockingQueue.contains(delayObject3));

        System.out.println(
            "Size of the ArrayBlocingQueue             : "
            + arrayBlockingQueue.size());
    }
}