// CSE 373, Winter 2013, Marty Stepp
// A HeapIntPriorityQueue implements a priority queue of integers using a
// binary min-heap array of integers as the internal data structure.

import java.util.Arrays;

public class HeapIntPriorityQueue implements IntPriorityQueue {
	private int[] elements;
	private int size;

	// ...
	public HeapIntPriorityQueue() {
		elements = new int[10];
		size = 0;
	}

	// ...
	public void add(int value) {
		// resize if needed
		if (size + 1 >= elements.length) {
			elements = Arrays.copyOf(elements, 2 * elements.length);
		}
		
		int index = size + 1;
		elements[index] = value;  // put in last slot
		
		// "bubble up" until in order again
		while (index > 1) {
			int daddy = parent(index);
			if (elements[daddy] <= elements[index]) {
				break;
			}
			swap(elements, index, daddy);
			index = daddy;
		}
		size++;
	}

	// ...
	public void clear() {
		// TODO: implement this method
		
	}

	// ...
	public boolean isEmpty() {
		// TODO: implement this method
		return true;
	}

	// ...
	public int peek() {
		// bug: assumes that queue is not empty
		return elements[1];
	}

	// ...
	public int remove() {
		// TODO: implement this method
		int result = elements[1];
		
		elements[1] = elements[size];
		elements[size] = 0;
		size--;
		
		// bubble down until order is restored
		// (** We did not complete remove(); will finish Friday)
		int index = 1;
		while (true) {
			int left = leftChild(index);
			int right = rightChild(index);
			
			if (elements[index] <= elements[left] &&
					elements[index] <= elements[right]) {
				break;
			}
			if (elements[left] <= elements[right]) {
				swap(elements, index, left);
				index = left;
			} else {
				swap(elements, index, right);
				index = right;
			}
		}
		
		
		return result;
	}

	public int size() {
		return size;
	}
	
	public String toString() {
		// this is an incorrect implementation for debugging
		return Arrays.toString(elements);
	}
	
	
	// helpers for navigating indexes up/down the tree
	private int parent(int index) {
		return index / 2;
	}
	
	// Returns the index of the left child of the given index in the heap.
	private int leftChild(int index) {
		return index * 2;
	}

	// Returns the index of the right child of the given index in the heap.
	private int rightChild(int index) {
		return index * 2 + 1;
	}

	// Returns true if the given index has a parent in the heap (true for all elements above 1).
	private boolean hasParent(int index) {
		return index > 1;
	}

	// Returns true if the given index has a left child element in the heap.
	private boolean hasLeftChild(int index) {
		return leftChild(index) <= size;
	}

	// Returns true if the given index has a right child element in the heap.
	private boolean hasRightChild(int index) {
		return rightChild(index) <= size;
	}
	
	// Swaps the elements at the two given indexes in the array.
	private void swap(int[] a, int index1, int index2) {
		int temp = a[index1];
		a[index1] = a[index2];
		a[index2] = temp;
	}
}