/* *~*~*
Specification file for the Heap class: min- or max-heap of integers
Written By: Iurii Tatishchev
Changed by: Iurii Tatishchev
IDE: CLion
*~**/

#ifndef HEAP_H_
#define HEAP_H_

template<typename T>
class Heap {
private:
    T *heapAry;
    int heapSize;
    int count;

    void _reHeapUp(int lastndx, int (compareFunc)(const T&, const T&));

    void _reHeapDown(int rootndx, int (compareFunc)(const T&, const T&));

    int _findParent(int index) { return (index <= 0) ? (-1) : (index - 1) / 2; }

    int _findLeftChild(int index) { return (2 * index + 1 >= count) ? (-1) : (2 * index + 1); }

    int _findRightChild(int index) { return (2 * index + 2 >= count) ? (-1) : (2 * index + 2); }

public:
    Heap() {
        count = 0;
        heapSize = 128;
        heapAry = new T[heapSize];
    }

    Heap(int n) {
        count = 0;
        heapSize = n;
        heapAry = static_cast<int *>(new T[heapSize]);
    }

    ~Heap() { delete[] heapAry; }

    int getCount() const { return count; }

    int getSize() const { return heapSize; }

    bool isEmpty() const { return count == 0; }

    bool isFull() const { return count == heapSize; }

    bool insertHeap(T &itemIn, int (compareFunc)(const T&, const T&));

    bool deleteHeap(T &itemOut, int (compareFunc)(const T&, const T&));

};

template <typename T>
void Heap<T>::_reHeapUp(int lastndx, int (compareFunc)(const T&, const T&)) {

    // base case, newElement is heap's root
    if (lastndx == 0) return;

    int parentIndex = _findParent(lastndx);
    // base case, newElement satisfies heap property
    // min heap - child not less than parent
    // max heap - child not greater than parent
    if (compareFunc(heapAry[lastndx], heapAry[parentIndex]) != -1) return;

    // swap and continue recursing
    std::swap(heapAry[lastndx], heapAry[parentIndex]);
    _reHeapUp(parentIndex, compareFunc);
}

/* *~*~*
 The private member function _reHeapDown rearranges the heap after delete by moving the
 data in the root down to the correct location in the heap
 *~**/
template <typename T>
void Heap<T>::_reHeapDown(int rootdex, int (compareFunc)(const T&, const T&)) {
    int maxChildIndex = -1;

    int left = _findLeftChild(rootdex);
    int right = _findRightChild(rootdex);

    // if there is a left child
    if (left != -1) {
        // if there is a right child that is
        // min heap - less than the left child
        // max heap - greater than the left child
        if (right != -1 && compareFunc(heapAry[right], heapAry[left]) == -1) maxChildIndex = right;
        else maxChildIndex = left;
    }

    // base case, heap property satisfied
    // min heap - children greater than parent
    // max heap - children less than parent
    if (maxChildIndex == -1 || compareFunc(heapAry[rootdex], heapAry[maxChildIndex]) == -1) return;

    // swap and continue recursing
    std::swap(heapAry[rootdex], heapAry[maxChildIndex]);
    _reHeapDown(maxChildIndex, compareFunc);
}

/* *~*~*
 The public member function insertHeap inserts a new item into a heap.
 It calls _reheapUp.
 *~**/
template <typename T>
bool Heap<T>::insertHeap(T& newItem, int (compareFunc)(const T&, const T&)) {
    if (isFull()) return false;

    heapAry[count] = newItem;
    _reHeapUp(count, compareFunc);
    count++;

    return true;
}

/* *~*~*
 The public member function deleteHeap deletes the root of the heap and
 passes back the root's data. It calls _reheapDown.
 *~**/
template <typename T>
bool Heap<T>::deleteHeap(T& returnItem, int (compareFunc)(const T&, const T&)) {
    if (isEmpty()) return false;

    returnItem = heapAry[0];
    heapAry[0] = heapAry[count - 1];
    count--;
    _reHeapDown(0, compareFunc);

    return true;
}

#endif