/**
 * CSE 373, Spring 2011, Jessica Miller
 * A generic implementation of a Priority Queue backed by a minimum
 * binary heap.
 */
import java.util.Arrays;
import java.util.NoSuchElementException;

public class BinaryHeapPQ<E extends Comparable<E>> implements GenericPriorityQueue<E> {
    private static final int DEFAULT_CAPACITY = 10;
    private E[] array;
    private int size;
    
    @SuppressWarnings("unchecked")
	public BinaryHeapPQ () {
        array = (E[])(new Comparable[DEFAULT_CAPACITY]);
        size = 0;
    }
    
    public void add(E value) {
    	size++;
    	
    	// check if full
    	if (size == array.length){
    		resize();
    	}
    	
    	array[size] = value;
    	bubbleUp();
    }
    
    private void bubbleUp() {
    	int i = size;
    	
    	while (hasParent(i) && parent(i).compareTo(array[i]) > 0) {
    		swap(i, parentIndex(i));
    		i = parentIndex(i);
    	}
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    public E peek() {
    	if (size == 0) {
    		throw new NoSuchElementException();
    	}
    	
    	return array[1];
    }

    public E remove() {
    	E result = peek();
    	array[1] = array[size];
    	array[size] = null;
    	size--;
    	
    	bubbleDown();
    	
    	return result; 
    }
    
    private void bubbleDown() {
    	int i = 1;
    	int minChildIndex = i;
    	
    	// verify that there are children
    	while (hasLeftChild(i)) {
    		// figure out which of my children is smaller
    		minChildIndex = leftIndex(i);
    		if (hasRightChild(i) 
    				&& array[rightIndex(i)].compareTo(array[leftIndex(i)]) < 0) {
    			minChildIndex = rightIndex(i);
    		}
    		
    		// am i bigger than my smallest child?
    		if (array[i].compareTo(array[minChildIndex]) > 0) {
    			swap(i, minChildIndex);
    			i = minChildIndex;
    		} else {
    			break;
    		}
    	}
    }
    
    public String toString() {
        return Arrays.toString(array);
    }
    
    private boolean hasParent(int i) {
        return i > 1;
    }
    
    private E parent(int i) {
        return array[parentIndex(i)];
    }
    
    private int parentIndex(int i) {
        return i / 2;
    }
    
    private void resize() {
        array = Arrays.copyOf(array, array.length * 2);
    }     
    
    private void swap(int index1, int index2) {
        E tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;        
    }
    
    private int leftIndex(int i) { 
    	return i * 2; 
    }
    
    private int rightIndex(int i) { 
    	return i * 2 + 1; 
    }
    
    private boolean hasLeftChild(int i) { 
    	return leftIndex(i) <= size; 
    }
    
    private boolean hasRightChild(int i) { 
    	return rightIndex(i) <= size; 
    }    
}