/**
  * @param <K> the Key element. This must implement Comparable.
 * @param <V> The Value element.  This could be anything.
 * 
 * For methods that exactly follow the interface, see the documentation in 
 * the interface.  This implements a priority queue built on top of an 
 * unordered array.
 * 
 * @author gtowell
 * Created APRIL 6, 2020
 * Modified: 
 */
public class PriorityQueue<K extends Comparable<K>, V>  extends AbstractPriorityQueue<K,V> {
    
    private int getNextt() {
        if (size==0) return -1;
        int tmpi = 0;
        Pair<K,V> tmp = pqStore[tmpi];
        for (int j=1; j<size; j++) {
            if (tmp.compareTo(pqStore[j]) < 0) {
                tmpi=j;
                tmp=pqStore[j];
            }
        }

        return tmpi;
    }

    private void removee(int loc) {
        for( int j=loc; j<(size-1); j++) {
            pqStore[j] = pqStore[j+1];
        }
        pqStore[size-1]=null;
        size--;
    }
    private static int CAPACITY = 200;

    /** The thing actually holding the data in the priority queue.  Using an ArrayList
     * to get unbounded length.  
     */
    private Pair<K,V>[] pqStore;

    /** THe number of items in the priority queue */
    private int size;

    /**
     * Initialize the priority queue
     */
    public PriorityQueue() {
        this(Ordering.MIN);
    }

    @SuppressWarnings("unchecked")
    public PriorityQueue(Ordering order) {
        this.order=order;
        pqStore = (Pair<K,V>[]) new Pair[CAPACITY];
        this.size=0;
    }


    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size==0;
    }

    public boolean offer(K newK, V newV) {
        if (size==CAPACITY)
            return false;
        Pair<K,V> entry = new Pair<>(newK, newV);
        pqStore[size]=entry;
        size++;
        return true;
    }

    /**
     * find and return the index of the next item from the priority queue
     * @return the next item
     */
    private int  getNext() {
        if (isEmpty())
            return -1;
        // if there are entries, then go through them all to find the next one.
        // must do this because entries are in no particular order.
        int lmin = 0; 
        for (int i=1; i<size; i++) {
            Pair<K,V> curr = pqStore[i];
            if (pqStore[lmin].compareTo(curr) > 0) {
                lmin=i;
            }
        }
        return lmin;
    }

    private void remove(int lmin) {
        for (int i=lmin; i<size-1; i++) {
            pqStore[i] = pqStore[i+1];
        }
        pqStore[size-1]=null;
        size--;
    }

    public V poll() {
        if (size==0)
            return null;
        if (size==1) {
            Pair<K,V> entry = pqStore[0];
            pqStore[0]=null;
            size=0;
            return entry.theV;
        }
        int lmin = getNext();
        Pair<K,V> entry = pqStore[lmin];
        remove(lmin);
        return entry.theV;
    }

    public V peek() {
        int lmin = getNext();
        if (lmin<0)
            return null;
        Pair<K,V> entry = pqStore[lmin];
        return entry.theV;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i=0; i<size; i++)
        sb.append(i+pqStore[i].toString());
        sb.append(" ");
        return sb.toString();
    }
    public static void main(String[] args) {
        PriorityQueue<Integer, String> pq = new PriorityQueue<>(Ordering.ASCENDING);
        pq.offer(1,"Jane");
        pq.offer(10,"WET");
        pq.offer(5, "WAS");
        System.out.println(pq);
        System.out.println(pq.poll());
        System.out.println(pq);
        System.out.println(pq.poll());
        System.out.println(pq);
        System.out.println(pq.poll());
        System.out.println(pq);
        System.out.println();

        pq = new PriorityQueue<>(Ordering.DESCENDING);
        pq.offer(1,"Jane");
        pq.offer(10,"WET");
        pq.offer(5, "WAS");
        System.out.println(pq.poll());
        System.out.println(pq.poll());
        System.out.println(pq.poll());
    }

}