//delete the root
  int realDelete(int ar[], int pos, heapNode *parent, heapNode *deleteNode, heapNode *root)
  {
    if(ar[pos] == 0)
    {
      if (parent->getLeft() == NULL)
      {
        deleteNode->setValue(root->getValue());
    	root->setValue(parent->getValue());
      }
      if(root->getValue() < parent->left->getValue())
        parent->setValue(parent->left->getValue());
      else
	realDelete(ar, pos-1, parent->left, deleteNode, root);
    }
    else if(ar[pos] == 1)
    {
	if (parent->getRight() == NULL)
	{
	  deleteNode->setValue(root->getValue());
          root->setValue(parent->getValue());
        }
        if(root->getValue() < parent->right->getValue())
          parent->setValue(parent->right->getValue());
	else
	  realDelete(ar, pos-1, parent->right, deleteNode, root);
    }
    return deleteNode->getValue();
 }

// add, print and delete a number from a binary min heap

#include <iostream>
using namespace std;

// node containing int value and left and right pointers
// constructor, get value, get right, get left, set value, set left, set right
class heapNode
{
  private:
  int value;

  public:
  heapNode *left;
  heapNode *right;

  //constructor
  heapNode(int newValue)
  {
     value = newValue;
     left = NULL; 
     right = NULL;
  }
 
  //get value
  int getValue()
  {
    return value;
  }
  
  //get right
  heapNode* getRight()
  {
    return right;
  }

  //get left
  heapNode* getLeft()
  {
    return left;
  }

  //set value
  void setValue(int newValue)
  {
    value = newValue;
  }

  // set right
  void setRight(heapNode *newRight)
  {
    right = newRight;
  }

  // set left
  void setLeft(heapNode *newLeft)
  {
    left = newLeft;
  }
  
}; // end of heapNode class

class heap
{
  private:
  heapNode *root;
  int counter;

public:
  //constructor
  heap()
  {
    counter = 0;
    root = NULL;
  }

  //insert new value, check to see if swap is needed
  void realInsert(int ar[], int pos, heapNode *parent, heapNode *newNode)
  {
    if(ar[pos] == 0)
    {
      if (parent->getLeft() == NULL)
	parent->setLeft(newNode);
      else
	realInsert(ar, pos-1, parent->left, newNode);
      if(parent->getLeft()->getValue() < parent->getValue())
      {
	int tempParentLeft = parent->getLeft()->getValue();
        int tempParent = parent->getValue();
        parent->setValue(tempParentLeft);
        parent->left->setValue(tempParent);
      }
    }
    else if(ar[pos] == 1)
    {
	if (parent->getRight() == NULL)
	  parent->setRight(newNode);
	else
	  realInsert(ar, pos-1, parent->right, newNode);
      if(parent->getRight()->getValue() < parent->getValue())
      {
        int tempParentRight = parent->getRight()->getValue();
        int tempParent = parent->getValue();
        parent->setValue(tempParentRight);
        parent->right->setValue(tempParent);
      }
    }
  }

  // find the spot to put new value
  void insertSpot(int option)
  {
    heapNode *newNode = new heapNode(option);
    counter++;
    if(root == NULL)
    {
      root = newNode;
    }

    else
    {
      int arrayValue;
      bool isOne = false;
      int ar[32];
      int i;
      int temp = counter;
      for(i = 0; i < 32; i++)
      {
          arrayValue = temp % 2;
          temp = temp / 2;
          ar[i] = arrayValue;
      }
 
      for(i = 0; i < 32; i++)
        cout << ar[i] << " ";
      cout << endl;

      i=31;
      while(i >= 0)
      {
        if(ar[i] == 1)
          isOne = true;
        if(isOne == true)
          break;
        i--;
      }
      i--;
      cout << "Broke loop with i = " << i << endl;
      realInsert(ar, i, root, newNode);
    }
  }
   
  //call printNode
  void print()
  {
    cout << "Printing the heap...\n";
    printNode(root, 0);
  }
  
  //print tree with spaces for levels of the tree
  void printNode(heapNode *node, int level)
  {
    if(node != NULL)
    {
       printNode(node->getLeft(), level + 1);
      for(int i = 0; i < level; i++)
        cout << "\t";
      cout << node->getValue();
      cout << "\n";
      printNode(node->getRight(), level + 1);
     }
    }

  // get root
  heapNode* getRoot()
  {
    return root;
  }

  //delete the root
  int realDelete(int ar[], int pos, heapNode *parent, heapNode *deleteNode, heapNode *root)
  {
    if(ar[pos] == 0)
    {
      if (parent->getLeft() == NULL)
      {
        deleteNode->setValue(root->getValue());
    	root->setValue(parent->getValue());
      }
      if(root->getValue() < parent->left->getValue())
        parent->setValue(parent->left->getValue());
      else
	realDelete(ar, pos-1, parent->left, deleteNode, root);
    }
    else if(ar[pos] == 1)
    {
	if (parent->getRight() == NULL)
	{
	  deleteNode->setValue(root->getValue());
          root->setValue(parent->getValue());
        }
        if(root->getValue() < parent->right->getValue())
          parent->setValue(parent->right->getValue());
	else
	  realDelete(ar, pos-1, parent->right, deleteNode, root);
    }

    return deleteNode->getValue();
  }


/*
    int delete(rootValue)
    {
        heapNode *tempNode = new heapNode(value, *left, *right)
        go down the heap to the last one
        make it root
        last nodeValue = null
	while(not at the bottom level of tree)
	{
	  if(newRoot < *left)
	    break;
          elseif(newRoot > *left)
	    swap with left;
        }

        return tempNode;         
     }
*/

  }; // end of heap class

// menu with add, print, delete choices  call methods from heap class
int main()
{
  heap *myHeap;
  
  myHeap = new heap();


  int option=9;
  while (option != 0) {
    cout << "Please enter a number: ";
    cin >> option;
    myHeap->insertSpot(option);
    myHeap->print();
    

    }

  myHeap->print();
  return 0;
}