// Stephen Bassoli
// CSE 124 Section 01
// Lab 7

#include <stdlib.h>

template <class T>
class BinTree;

template <class T>
class TreeNode
{
	private:
		TreeNode<T> *left;
		TreeNode<T> *right;
		TreeNode<T> *parent;
		T data;
	public:
		TreeNode(const T& item, TreeNode<T> *lptr = NULL, TreeNode<T> *rptr = NULL);
		//	Input:		None
		//	Precond:	None
		//	Process:	Constructor
		//	Output:		None
		//	Postcond:	None

		void ChangeData(const T& item);
		//	Input:		Data of item
		//	Precond:	None
		//	Process:	Changes nata of the node
		//	Output:		None
		//	Postcond:	None

		T& Data(void);
		//	Input:		None
		//	Precond:	None
		//	Process:	Returns data of the node
		//	Output:		Returns data of the node
		//	Postcond:	None

		TreeNode<T>* Left(void);
		//	Input:		None
		//	Precond:	None
		//	Process:	None
		//	Output:		Returns node to the left
		//	Postcond:	None

		TreeNode<T>* Right(void);
		//	Input:		None
		//	Precond:	None
		//	Process:	None
		//	Output:		Returns node to the right
		//	Postcond:	None

		TreeNode<T>* Up(void);
		//	Input:		None
		//	Precond:	None
		//	Process:	None
		//	Output:		Returns the parent node
		//	Postcond:	None

		void SetLeft(TreeNode<T>* lptr);
		//	Input:		Node to be set to the left
		//	Precond:	None
		//	Process:	Set node to the left
		//	Output:		None
		//	Postcond:	None

		void SetRight(TreeNode<T>* rptr);
		//	Input:		Node to be set to the right
		//	Precond:	None
		//	Process:	Set node to the right
		//	Output:		None
		//	Postcond:	None

		void RemoveLeft(void);
		//	Input:		None
		//	Precond:	None
		//	Process:	Sets left to NULL
		//	Output:		None
		//	Postcond:	None

		void RemoveRight(void);
		//	Input:		None
		//	Precond:	None
		//	Process:	Sets right to NULL
		//	Output:		None
		//	Postcond:	None

		void RemoveSelfFromUp(void);
		//	Input:		None
		//	Precond:	None
		//	Process:	Removes self from parent
		//	Output:		None
		//	Postcond:	None

		bool LookLeft(void)const;
		//	Input:		None
		//	Precond:	None
		//	Process:	Sees if there is a node to the left
		//	Output:		Returns true if there is no node to the left
		//	Postcond:	None

		bool LookRight(void)const;
		//	Input:		None
		//	Precond:	None
		//	Process:	Sees if there is a node to the right
		//	Output:		Returns true if there is no node to the right
		//	Postcond:	None

		T& WhatLeft(void);
		//	Input:		None
		//	Precond:	None
		//	Process:	None
		//	Output:		Returns data of left
		//	Postcond:	None

		T& WhatRight(void);
		//	Input:		None
		//	Precond:	None
		//	Process:	None
		//	Output:		Returns data of right
		//	Postcond:	None

		T& WhatUp(void);
		//	Input:		None
		//	Precond:	None
		//	Process:	None
		//	Output:		Returns data of parent
		//	Postcond:	None

};

template <class T>
TreeNode<T>::TreeNode(const T& item, TreeNode<T> *lptr, TreeNode<T> *rptr)
{
	parent = NULL;
	left = lptr;
	right = rptr;
	data = item;
}

template <class T>
void TreeNode<T>::ChangeData(const T& item)
{
	data = item;
}

template <class T>
T& TreeNode<T>::Data(void)
{
	return data;
}

template <class T>
TreeNode<T>* TreeNode<T>::Left(void)
{
	if (left == NULL)
		return NULL;
	else
		return left;
}

template <class T>
TreeNode<T>* TreeNode<T>::Right(void)
{
	if (right == NULL)
		return NULL;
	else
		return right;
}

template <class T>
TreeNode<T>* TreeNode<T>::Up(void)
{
	if (parent == NULL)
		return NULL;
	else
		return parent;
}

template <class T>
void TreeNode<T>::SetLeft(TreeNode<T>* lptr)
{
	left = lptr;
	left->parent = this;
}

template <class T>
void TreeNode<T>::SetRight(TreeNode<T>* rptr)
{
	right = rptr;
	right->parent = this;
}

template <class T>
void TreeNode<T>::RemoveLeft(void)
{
	left = NULL;
}

template <class T>
void TreeNode<T>::RemoveRight(void)
{
	right = NULL;
}

template <class T>
void TreeNode<T>::RemoveSelfFromUp(void)
{
	if (parent->Left() == this)
		parent->RemoveLeft();
	else if (parent->Right() == this)
		parent->RemoveRight();
}

template <class T>
bool TreeNode<T>::LookLeft(void)const
{
	if (left == NULL)
		return true;
	else return false;
}


template <class T>
bool TreeNode<T>::LookRight(void)const
{
	if (right == NULL)
		return true;
	else return false;
}

template <class T>
T& TreeNode<T>::WhatLeft(void)
{
	return left->Data();
}

template <class T>
T& TreeNode<T>::WhatRight(void)
{	
	return right->Data();
}

template <class T>
T& TreeNode<T>::WhatUp(void)
{
	return parent->Data();
}