// LIST.CPP

#ifndef __LIST_CPP
#define __LIST_CPP

#include "list.h"

void Error_1_List();

int List::list_count = 0;

List::List()
{
	++list_count;
	list_id = list_count;
	leftlist = NULL;
	rightlist = NULL;
	nodes_in_list = 0;

	HeadNode = (Node*) NULL;
	TailNode = (Node*) NULL;
	CurrentNode = (Node*) NULL;

	strcpy( list_name, "\"NO NAME\"" );
}

List::List( char *name )
{
	++list_count;
	list_id = list_count;
	leftlist = NULL;
	rightlist = NULL;
	nodes_in_list = 0;

	HeadNode = NULL;
	TailNode = NULL;
	CurrentNode = NULL;

	if( strlen(name) != 0 )
		strcpy( list_name, name );
	else
		strcpy( list_name, "\"NO NAME\"" );
}

inline List::~List(){ Delete_All(); }


inline int List::List_Count( void ) const
{
	return( list_count );
}

inline int List::List_ID( void ) const
{
	return( list_id );
}

inline char *List::List_Name( void )
{
	return( list_name );
}

inline int List::Nodes_In_List( void ) const
{
	return( nodes_in_list );
}

List *List::ConnectTo( List *Left ) // RIGHT OF
{
List *Right = Left->rightlist;

	if( Left )
	{
		rightlist = Right;
		Left->rightlist = this;
		leftlist = Left;

		if( Right )
			Right->leftlist = this;

		return( this );
	}

	else
		return( NULL );
}

List *List::Disconnect()
{
List *Left = leftlist;
List *Right = rightlist;

	if( Left )
		Left->rightlist = Right;

	if( Right )
		Right->leftlist = Left;

	return( this );
}

inline List *List::Get_Left_List()
{
	return( leftlist );
}

inline List *List::Get_Right_List()
{
	return( rightlist );
}

void List::Print()
{
	cout << " : " << List_Name()
	     << " : LIST ID: " << List_ID() << " :"
	     << " NODES: " << Nodes_In_List() << " :"
	     << " TOTAL NODES: " << HeadNode->Node_Count() << " :\n";
}

void List::Print_Head()
{
Node *ptr = HeadNode;

	List::Print();
	cout << " TOP  ==>";

	if( ptr )
	{
		ptr->Print();
		ptr = ptr->Get_Right_Node();
	}

	while( ptr )
	{
		cout << "\n\t ";
		ptr->Print();
		ptr = ptr->Get_Right_Node();
	}

	cout << " <== BOTTOM \n\n";
}

void List::Print_Tail()
{
Node *ptr = TailNode;

	Print();
	cout << " TOP  ==>";

	if( ptr )
	{
		ptr->Print();
		ptr = ptr->Get_Left_Node();
	}

	while( ptr )
	{
		cout << "\n\t ";
		ptr->Print();
		ptr = ptr->Get_Left_Node();
	}

	cout << " <== BOTTOM \n\n";
}

Node *List::Create_Node()
{
Node *temp;

	_new_handler = &Error_1_List;
	temp = new Node;
	CurrentNode = temp;
	++nodes_in_list;
	return( temp );
}

Node *List::Create_Node( char *str )
{
Node *temp;

	_new_handler = &Error_1_List;
	temp = new Node( str );
	CurrentNode = temp;
	++nodes_in_list;
	return( temp );
}


inline void List::Delete_Node()
{
	CurrentNode->Disconnect();
	--nodes_in_list;
	delete CurrentNode;
}

int List::Find_Node( int id )
{
CurrentNode = HeadNode;
int found = 0x0;

	while( !found && CurrentNode )
	{
		if( CurrentNode->Node_ID() == id )
			found += 0xFF;
		else
			CurrentNode = CurrentNode->Get_Right_Node();
	}

	return( found );
}

int List::Find_Node( char *str )
{
CurrentNode = HeadNode;
int found = 0x0;
Node *ordered = HeadNode;

	while( !found && CurrentNode )
	{
		if( strcmp(str, CurrentNode->Peek()) > 0 )
			ordered = CurrentNode;

		if( strcmp(CurrentNode->Peek(), str) == 0 )
			found += 0xFF;

		else
			CurrentNode = CurrentNode->Get_Right_Node();
	}

	if( !found )
		CurrentNode = ordered;

	return( found );
}

void List::Add_to_Head( char *str )
{
	if( HeadNode )
	{
		Create_Node( str );
		CurrentNode->Connect_Left_of( HeadNode );
		HeadNode = CurrentNode;
	}

	else
	{
		HeadNode = Create_Node( str );
		TailNode = HeadNode;
		CurrentNode = HeadNode;
	}
}

void List::Add_to_Tail( char *str )
{
	if( TailNode )
	{
		Create_Node( str );
		CurrentNode->Connect_Right_of( TailNode );
		TailNode = CurrentNode;
	}

	else
	{
		TailNode = Create_Node( str );
		HeadNode = TailNode;
		CurrentNode = TailNode;
	}
}

int List::Insert_Ordered( char *str )
{
Node *temp;

	if( HeadNode )
	{
		if ( ! Find_Node(str) )
		{
			temp = Create_Node( str );

			if( strcmp(str, HeadNode->Peek()) < 0 )
			{
				temp->Connect_Left_of( HeadNode );
				HeadNode = temp;
			}

			else
			{
				Find_Node( str );
				temp->Connect_Right_of( CurrentNode );

				if( TailNode == CurrentNode )
					TailNode = temp;
			}

			return( 0xFF );
		}

		else
			return( 0x0 );
	}

	else
	{
		HeadNode = Create_Node( str );
		TailNode = HeadNode;
		CurrentNode = HeadNode;
		return( 0xFF );
	}
}

char *List::Delete_Node( int x )
{
	strcpy( buffer, "" );

	if( Find_Node( x ) )
	{
		if( HeadNode == CurrentNode )
			HeadNode = HeadNode->Get_Right_Node();

		if( TailNode == CurrentNode )
			TailNode = TailNode->Get_Left_Node();

		strcpy( buffer, CurrentNode->Peek() );
		Delete_Node();
	}

	return( buffer );
}

char *List::Delete_Node( char *str )
{
	strcpy( buffer, "" );

	if( Find_Node( str ) )
	{
		if( HeadNode == CurrentNode )
			HeadNode = HeadNode->Get_Right_Node();

		if( TailNode == CurrentNode )
			TailNode = TailNode->Get_Left_Node();

		strcpy( buffer, CurrentNode->Peek() );
		Delete_Node();
	}

	return( buffer );
}

char *List::Delete_Head()
{
	strcpy( buffer, "" );

	if( HeadNode )
	{
		CurrentNode = HeadNode;
		HeadNode = HeadNode->Get_Right_Node();

		if( TailNode == CurrentNode )
			TailNode = TailNode->Get_Left_Node();

		strcpy( buffer, CurrentNode->Peek() );
		Delete_Node();
	}

	return( buffer );
}

char *List::Delete_Tail()
{
	strcpy( buffer, "" );

	if( TailNode )
	{
		CurrentNode = TailNode;
		TailNode = TailNode->Get_Left_Node();

		if( HeadNode == CurrentNode )
			HeadNode = HeadNode->Get_Right_Node();

		strcpy( buffer, CurrentNode->Peek() );
		Delete_Node();
	}

	return( buffer );
}

void List::Delete_All()
{
	while( HeadNode )
		Delete_Head();
}

void List::Append_Node( int x, char *str )
{
	cout << "APPEND NODE #" << x << " IN";
	Print();

	if( Find_Node( x ) )
	{
		*CurrentNode << str;
		CurrentNode->Print();
	}
	else
		cout << "APPEND NODE #" << x << " NOT FOUND !";

	cout << "\n\n";
}

void List::Find( char *str )
{
	cout << "FIND ==>" << str << "<== IN";
	Print();

	if( Find_Node( str ) )
		CurrentNode->Print();
	else
		cout << "FIND ==>" << str << "<== NOT FOUND !";

	cout << "\n\n";
}

void List::Find( int x )
{
	cout << "FIND NODE #" << x << " IN";
	Print();

	if( Find_Node( x ) )
		CurrentNode->Print();
	else
		cout << "FIND NODE #" << x << " NOT FOUND !";

	cout << "\n\n";
}

int List::Insert( char *x) { return( (int) x ); }
char *List::Remove( int x ) { x++; return( (char) NULL ); }
void List::EnQueue( char *x ) { *x++; }
char *List::DeQueue() { return( (char) NULL ); }
void List::Push( char *x ) { *x++; }
char *List::Pop() { return( (char) NULL ); }


void Error_1_List()
{
	cerr << "\n\n\t MEMORY ERROR: NEW in List::Create_Node. ";
	exit ( 1 );
}

#endif  // __LIST_CPP