#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
#include "splay.h"

#define TRUE 1
#define FALSE 0

// Insert element into tree, return FALSE, if node is already in tree
int insert(uint32_t num, Node newNode, Node* root) {
  if (*root == NULL) {
    *root = newNode;
    return TRUE;
  }
  splay(num, root);
  int rootValue = (*root)->value;
  if (rootValue == num) return FALSE;
  if (rootValue < num) {
    newNode->leftChild = *root;
    newNode->rightChild = (*root)->rightChild;
    (*root)->rightChild = NULL;
    *root = newNode;
    return TRUE;
  }
  newNode->leftChild = (*root)->leftChild;
  newNode->rightChild = *root;
  (*root)->leftChild = NULL;
  *root = newNode;
  return TRUE;  
}


// Finds a node, returns node or FALSE, if not found.
int get(uint32_t num, Node* root) {
  if (*root == NULL) return FALSE;
  splay(num, root);
  return (*root)->value;
}

void splay(uint32_t num, Node* root) {
  Node n = *root;
  Node leftTree = NULL;
  Node rightTree = NULL;
  Node tempLeft = NULL;
  Node tempRight = NULL;

  while (TRUE) {
    if (n->value == num) {
      // found it, reassemble tree
      *root = reassemble(n, leftTree, rightTree);
      return;
    } else if (num < n->value) {
      // go to left child
      tempLeft = n->leftChild;
      if (tempLeft == NULL) {
	*root = reassemble(n, leftTree, rightTree);
	return;
      } else {
	// we have a left child
	if (tempLeft->value == num) {
	  // found it
	  rightTree = moveToRightTree(rightTree, n);
	  n->leftChild = NULL;
	  *root = reassemble(tempLeft, leftTree, rightTree);
	  return;
	} else if (num < tempLeft->value) {
	  // go to left grandchild
	  if (tempLeft->leftChild == NULL) {
	    // not found
	    rightTree = moveToRightTree(rightTree, n);
	    n->leftChild = NULL;
	    *root = reassemble(tempLeft, leftTree, rightTree);
	    return;
	  } else {
	    // do a zigzig on left child and go on
	    n->leftChild = tempLeft->rightChild;
	    tempLeft->rightChild = n;
	    rightTree = moveToRightTree(rightTree, tempLeft);	    
	    n = tempLeft->leftChild;
	    tempLeft->leftChild = NULL;
	  }
	} else {
	  // go to right grandchild
	  if (tempLeft->rightChild == NULL) {
	    // not found
	    rightTree = moveToRightTree(rightTree, n);
	    n->leftChild = NULL;
	    *root = reassemble(tempLeft, leftTree, rightTree);
	    return;
	  } else if (tempLeft->rightChild-> value == num) {
	    // found it
	    rightTree = moveToRightTree(rightTree, n);
	    n->leftChild = NULL;
	    *root = reassemble(tempLeft, leftTree, rightTree);
	    return;
	  } else {
	    // do a zig on left child and go on
	    rightTree = moveToRightTree(rightTree, n);
	    n->leftChild = NULL;
	    n = tempLeft;
	  }
	}
      }
    } else {
      // go to right child
      tempRight = n->rightChild;
      if (tempRight == NULL) {
	*root = reassemble(n, leftTree, rightTree);
	return;
      } else {
	// we have a right child
	if (tempRight->value == num) {
	  // found it
	  leftTree = moveToLeftTree(leftTree, n);
	  n->rightChild = NULL;
	  *root = reassemble(tempRight, leftTree, rightTree);
	  return;
	} else if (tempRight->value < num) {
	  // go to right grandchild
	  if (tempRight->rightChild == NULL) {
	    // not found
	    leftTree = moveToLeftTree(leftTree, n);
	    n->rightChild = NULL;
	    *root = reassemble(tempRight, leftTree, rightTree);
	    return;
	  } else {
	    // do a zigzig on right child and go on
	    n->rightChild = tempRight->leftChild;
	    tempRight->leftChild = n;
	    leftTree = moveToLeftTree(leftTree, tempRight);	    
	    n = tempRight->rightChild;
	    tempRight->rightChild = NULL;
	  }
	} else {
	  // go to left grandchild
	  if (tempRight->leftChild == NULL) {
	    // not found
	    leftTree = moveToLeftTree(leftTree, n);
	    n->rightChild = NULL;
	    *root = reassemble(tempRight, leftTree, rightTree);
	    return;
	  } else if (tempRight->leftChild-> value == num) {
	    // found it
	    leftTree = moveToLeftTree(leftTree, n);
	    n->rightChild = NULL;
	    *root = reassemble(tempRight, leftTree, rightTree);
	    return;
	  } else {
	    // do a zig on left child and go on
	    leftTree = moveToLeftTree(leftTree, n);
	    n->rightChild = NULL;
	    n = tempRight;
	  }
	}
      }
    }
  }
}

Node moveToRightTree(Node rightTree, Node n){
  if (rightTree == NULL) return n;
  Node temp = rightTree;
  while (temp->leftChild != NULL) {
    temp = temp->leftChild;
  }
  temp->leftChild = n;
  return rightTree;
}

Node moveToLeftTree(Node leftTree, Node n){
  if (leftTree == NULL) return n;
  Node temp = leftTree;
  while (temp->rightChild != NULL) {
    temp = temp->rightChild;
  }
  temp->rightChild = n;
  return leftTree;
}


Node reassemble(Node x, Node leftTree, Node rightTree){
  Node temp;
  if (leftTree != NULL) {
    temp = leftTree;
    while(temp->rightChild != NULL) {
      temp = temp->rightChild;
    }
    temp->rightChild = x->leftChild;
    x->leftChild = leftTree;
  }
  if (rightTree != NULL) {
    temp = rightTree;
    while(temp->leftChild != NULL) {
      temp = temp->leftChild;
    }
    temp->leftChild = x->rightChild;
    x->rightChild = rightTree;
  }
  return x;
}



int height(Node root) {
  if (root == NULL) return -1;
  return heightHelper(root);
}
		   

int heightHelper(Node n) {
  int lheight = 0;
  int rheight = 0;
  if (n->leftChild != NULL) lheight = heightHelper(n->leftChild);
  if (n->rightChild != NULL) rheight = heightHelper(n->rightChild);
  if (lheight > rheight) return lheight + 1;
  return rheight + 1;
}


void printTree(Node n) {
	if (n == NULL) return;
	printf("[%d %d %d]\n",n->value, 
	                      (n->leftChild == NULL)?-1:n->leftChild->value, 
	                      (n->rightChild == NULL)?-1:n->rightChild->value);
	printTree(n->leftChild);
	printTree(n->rightChild);
}

uint32_t treeSize(Node n) { 
	if (n == NULL) return 0;
	return treeSize(n->leftChild) + treeSize(n->rightChild) + 1;
}

/*
 * Create a new node
 */
Node makeNode(uint32_t num) {
	Node n = (Node)malloc(sizeof(struct _Node));
	if (n == NULL) {
		printf("Error allocating memory for node with num %d\n", num);
		exit(1);
	}
	n->value = num;
	n->leftChild = NULL;
	n->rightChild = NULL;
	return n;
}