#include "functions prototype.h"
#include "include files.cpp"


using namespace std;


struct Node *Head=NULL;





//=========================================//
//clear screen
void clrscr()
{
     system("cls");
}
//=========================================//




//==========================================//
//		Add Node Methods
//==========================================//

Node* Allocate()
{
	Node * Ptr = new Node ;
   return Ptr;
}

//===========================================//



void AddNode( char *tName, int tID, int tQty, short int tDay, short int tMonth, int tYear)
{
	Node * Ptr = Allocate();
   
   
   
   	Ptr->Name = new char[strlen(tName)];
   	strcpy(Ptr->Name,tName);
   	Ptr->ID = tID;
   	Ptr->Quantity = tQty;
   	Ptr->Receive_Date.year = tYear;
   	Ptr->Receive_Date.month = tMonth;
   	Ptr->Receive_Date.day = tDay;
   	Ptr->Next = NULL;

   if(Head)
   	AddNode_Menu(Ptr);

   else
   	Head=Ptr;
   	
   	SaveToFile(Ptr); //save record to a file 
}

//=========================================//

void AddTo_Front( Node * NewNode )
{
	NewNode->Next = Head ;
   Head = NewNode ;
}

//=========================================//

void AddTo_End( Node * NewNode )
{
   Node * i = Head ;
	for( ; i->Next!=NULL; i=i->Next )
   {;}
	i->Next = NewNode ;
}

//=======================================//

void AddBefore_InBetween( Node * Flag , Node * NewNode )
{
	Node * i = Head ;
   for( ; i->Next != Flag; i=i->Next )
   {;}
   i->Next = NewNode ;
   NewNode->Next = Flag ;
}

//=========================================//

void AddAfter_InBetween( Node * Flag , Node * NewNode )
{
   NewNode->Next=Flag->Next;
   Flag->Next = NewNode ;
}

//=========================================//





//=========================================//
//			Search Node Methods
//=========================================//

Node* SearchBy_Name( char* tName )
{
   Node * i = Head ;
   for(  ; i!=NULL ; i = i->Next )
   	if(!strcmp(tName,i->Name))
         break;

   return i;
}

//========================================//

Node* SearchBy_ID( int tID )
{
   Node * i = Head ;
   for( ; i!=NULL ; i = i->Next )
      if(tID == i->ID)
        break;

   return i;
}

//==========================================//





//=========================================//
//	Delete Node Methods
//=========================================//

void DeleteFrom_Start()
{
   if(Head->Next)
	{
      Node * Temp = Head;
   	Head = Head -> Next;
      delete Temp;
   }

   else
   {
   	delete Head;
      Head = NULL;
   }
}

//=========================================//

void DeleteFrom_End()
{
   if( !Head->Next )
	{
      delete Head;
      Head = NULL;
   }

   else
   {
   	Node * i = Head;
      Node * j = NULL;
		for( ; i->Next!=NULL ; i = i->Next )
      {j=i;}
      j->Next = NULL;
      delete i;
   }
}

//========================================//

void DeleteIn_Between( Node * Current )
{
   Node * j = NULL;
   Node * i = Head;
	for( ; i!=Current ; i=i->Next)
   {j=i;}

   j->Next = i->Next;
   delete Current;
}

//========================================//






//======================================//
//	        Display
//======================================//

void Display()
{
    int records=1; 
	for(Node *i=Head;i!=NULL;i=i->Next)	
   {
      cout << "Records: " << records << endl;       
      cout << "Book ID: " << i->ID << endl;
      cout << "Book Name: " << i->Name << endl;
      cout << "Number Of Books: " << i->Quantity << endl;
      
      //display the date and add a zero if number less than 10
      if(i->Receive_Date.day < 10 && i->Receive_Date.month >= 10)
      {
        cout << "Received On: 0" << i->Receive_Date.day << "/" << i->Receive_Date.month << "/"  << i->Receive_Date.year << endl;
      }
      
      else if(i->Receive_Date.month < 10 && i->Receive_Date.day >= 10)
      {
        cout << "Received On: " << i->Receive_Date.day << "/0" << i->Receive_Date.month << "/"  << i->Receive_Date.year << endl;
      } 
       
      else if(i->Receive_Date.month < 10 && i->Receive_Date.day < 10)
      {
        cout << "Received On: 0" << i->Receive_Date.day << "/0" << i->Receive_Date.month << "/"  << i->Receive_Date.year << endl;
      }  
      
      else 
      {
           cout << "Received On: " << i->Receive_Date.day << "/" << i->Receive_Date.month << "/"  << i->Receive_Date.year << endl;
      }
      
      //print "----------------" after each book rcord 
      for(int j=0; j<=79; ++j)
              cout << "-";
              
      cout << endl;
      
      ++records;
      
      //cout<<i->Name<<":"<<i->ID<<endl;
      
   }
}

//=======================================//
// End of Re-usable functions, below are Menu Operation Launchers...
// End of Functionality




void MenuOperation( char Action )
{
   if(Head||Action=='1')
	switch( Action )
   {
   	case '1':
      {
         char tName[25];
         int tID, tQty, tYear;
         short int tDay, tMonth;
         
         cout<<"\n Enter book Details\n\n";

         cout<<"Enter Book ID: ";
         cin >> tID;
         
         //clear any error from input
         cin.ignore();
         cin.ignore(0);
         cin.clear();
         cin.sync();

         cout<<"Enter book title: ";
         cin.getline(tName, 25, '\n');
         
         cout<<"Enter Book Quantity: ";
         cin >> tQty;
         
         cin.ignore();
         cin.ignore(0);
         cin.clear();
         cin.sync();
         
         cout<<"Enter Year Received: ";
         cin >> tYear;
         
         cin.ignore();
         cin.ignore(0);
         cin.clear();
         cin.sync();
         
         cout<<"Enter Month Received(1-12): ";
         cin >> tMonth;
         
         cin.ignore();
         cin.ignore(0);
         cin.clear();
         cin.sync();
         
         cout<<"Enter Day Received(1-max(31)): ";
         cin >> tDay;
         
         cin.ignore();
         cin.ignore(0);
         cin.clear();
         cin.sync();
         
         
         
      	AddNode(tName,tID, tQty, tDay, tMonth, tYear);
         break;
      }

      case '2':
      {
         SearchMenu();
         break;
      }

      case '3':
      {
      	ModifyMenu();
         break;
      }

      case '4':
      {
         clrscr();
      	Display();
         getch();
         break;
      }

      case '5':
      {
      	DeleteMenu();
         break;
      }
   }

   else
   {
   	cout<<"Unable to Perfom operation on [Empty List]"<<endl;
      getch();
   }

}








//======================================//
//	Add Menu Operation Launcher
//======================================//

void AddNode_Menu( Node * NewNode )
{

		clrscr();
      cout<<"[1] Add to Front\n[2] Add to End\n[3] Add By Search_Before\n[4] Add By Search_After\n[0] ..Back"<<endl;
      char Choice = getch();

      Node* Flag = NULL;

      if(Choice!='0')
      {
      	switch(Choice)
      	{
      		case '1':
         	{
            	AddTo_Front(NewNode);
               break;
         	}

         	case '2':
         	{
            	AddTo_End(NewNode);
               break;
         	}

            case '3':
            case '4':
         	{
               clrscr();
               cout<<"[1] Add Before/After by Searching Name \n[2] Add Before/After by Searching ID\n";
               char SChoice = getch();

               switch(SChoice)
               {
                  case '1':
            		{
                  	char tName[25];
               		cout<<"Enter Name to Search Node : ";
               		gets(tName);
               		Flag = SearchBy_Name(tName);
                  	break;
               	}

                  case '2':
            		{
                  	int tID;
                     cout<<"Enter ID to Search Node : ";
               		cin>>tID;
               		Flag = SearchBy_ID(tID);
                  	break;
               	}
                  default:
                  	cout<<"\a";

               }

               if(Choice=='3')
               {
               	if(Flag)
               	{
               		if( Flag == Head )
                  	AddTo_Front(NewNode);

                  	else
                  	AddBefore_InBetween(Flag,NewNode);
               	}
         		}

               else
               {
                  if( Flag == Head || !Flag->Next )
                  {
                     NewNode->Next = Flag->Next;
                  	Flag->Next = NewNode;
                  }
                  else
               	AddAfter_InBetween(Flag,NewNode);
               }

               break;
               }

            default:
            	cout<<"\a";
      	}

         cout<<(Flag?"Added":"Couldn't Add");
      	getch();
      }


}


//======================================//
//    Search Menu Operation Launcher
//======================================//

void SearchMenu()
{
   char Choice = -1;
	while(Choice)
   {
   	clrscr();
      cout<<" 1. Search by Name\n   2. Search by ID\n[0] ..Back"<<endl;
      char Choice = getch();

      Node* Flag = NULL;

      if(Choice!='0')
      {
      	switch(Choice)
      	{
      		case '1':
         	{
            	char tName[25];
            	cout<<"Enter Name to Search: ";
            	gets(tName);
         		Flag = SearchBy_Name(tName);
               break;
         	}

         	case '2':
         	{
            	int tID;
            	cout<<"Enter ID to Search: ";
            	cin>>tID;
         		Flag = SearchBy_ID(tID);
            	break;
         	}

            default:
            	cout<<"\a";
      	}

         cout<<(Flag?"Found":"Not Found");
      	getch();
      }
      else
      	break;

   }
}




//==========================================//
//	Modify Menu Operation Launcher
//=========================================//

void ModifyMenu()
{
   char Choice = -1;
	while(Choice)
   {
   	clrscr();
      cout<<"[1] Modify Name\n[2] Modify ID\n[0] ..Back"<<endl;
      char Choice = getch();

      Node* Flag = NULL;

      if(Choice!='0')
      {
      	switch(Choice)
      	{
      		case '1':
         	{
            	char tName[25];
            	cout<<"Enter Name of book to Search then Modify: ";
            	gets(tName);
         		Flag = SearchBy_Name(tName);
               if(Flag)
               {
               	cout<<"Enter New Name to Modify ["<<tName<<"]: ";
                  gets(tName);
                  if(strcmp(Flag->Name,tName))
                  {
                  	delete Flag->Name;
                     Flag->Name = new char[strlen(tName)];
                  }
               	strcpy(Flag->Name,tName);
               }
               break;
         	}

         	case '2':
         	{
            	int tID;
            	cout<<"Enter book ID to Search";
            	cin>>tID;
         		Flag = SearchBy_ID(tID);
               if(Flag)
               {
                  cout<<"Enter New ID to Modify ["<<tID<<"]: ";
                  cin>>tID;
               	Flag->ID=tID;
               }
            	break;
         	}

            default:
            	cout<<"\a";
      	}

         cout<<(Flag?"Modified":"No record Found to Modify");
      	getch();
      }
      else
      	break;

   }
}

//=====================================//
//    Delete Menu Operation Launcher
//=====================================//

void DeleteMenu()
{
   char Choice = -1;
	while( Choice && Head )
   {
   	clrscr();
      cout<<"[1] Del Node from End\n[2] Delete Node from Front\n[3] Delete By Search_Name\n[4] Delete By Search_ID\n[0] ..Back"<<endl;
      char Choice = getch();

      Node* Flag = NULL;

      if(Choice!='0')
      {
      	switch(Choice)
      	{
      		case '1':
         	{
            	DeleteFrom_Start();
               break;
         	}

         	case '2':
         	{
            	DeleteFrom_End();
               break;
         	}

            case '3':
            case '4':
         	{

               switch(Choice)
               {
                  case '3':
            		{
                  	char tName[25];
               		cout<<"Enter BOOK title to Search then Delete Node: ";
               		gets(tName);
               		Flag = SearchBy_Name(tName);
                  	break;
               	}

                  case '4':
            		{
                  	int tID;
               		cout<<"Enter Book ID to Search then Delete Node: ";
               		cin>>tID;
               		Flag = SearchBy_ID(tID);
                  	break;
               	}

               }

               if(Flag)
               {
               	if( Flag == Head || !Flag->Next )
                  DeleteFrom_End();

                  else
                  DeleteIn_Between(Flag);
               }
               break;
         	}


            default:
            	cout<<"\a";
      	}

         cout<<(Flag?"Deleted":"Couldn't Delete");
      	getch();
      }
      else
      	break;
   }
}

void SaveToFile(Node *record)
{
     char *tName = new char[strlen(record->Name)]; //store name of book
     
     ofstream fout("book database.txt", ios::app);
     fout.clear();
     
     /* Save all records
     if(fout.is_open())
     {
           if(Head!=NULL && Head->Next==NULL)
           {
              Node *i = Head;            
              fout << i->ID << " " << tName << " " << i->Quantity << " " 
                   << i->Receive_Date.day << " " << i->Receive_Date.month << " " << i->Receive_Date.day << endl;    
           }
           
           else{
           for( Node *i=Head; i->Next!=NULL; i=i->Next )
           {
               cout << endl << i->ID;
                
               strcpy(tName, i->Name); //get name of book and add "+" to join name with spaces
               
               for (int j=0; j<strlen(tName)-1; ++j)
               {
                   if(tName[j] == ' ') tName[j] = '+';
               }    
               
               fout << i->ID << " " << tName << " " << i->Quantity << " " 
                    << i->Receive_Date.day << " " << i->Receive_Date.month << " " << i->Receive_Date.day << endl;
           }    
           }       
           
           fout.close(); 
     }
     */
     
     
     
     if(fout.is_open())
     {
        
        strcpy(tName, record->Name); //get name of book and store it in tName
        //tName = record->Name; //get name of book a
        
        
        //add "+" to join name with spaces  
        for (int j=0; j<strlen(tName)-1; ++j)
        {
             if(tName[j] == ' ') tName[j] = '+';
        }     
        
        fout << record->ID << " " << tName << " " << record->Quantity << " " 
                    << record->Receive_Date.day << " " << record->Receive_Date.month << " " << record->Receive_Date.year << endl;
                    
        fout.close(); 
     }
     
     else 
     {
          cout << "Error arises when opening file: book database.txt" << endl; 
          system("pause");
     }
     
     delete [] tName;
}


void loadFile()
{
     bool loaded = false; //true if there the function has loaded at least 1 record from a file
     ifstream fin;
     string tName;
     
     Node *temp_rec = new Node, *Last;
     
     fin.open("book database.txt");
     fin.clear();
     
     if(fin.is_open())
     {
           while(fin >> temp_rec->ID >> tName >> temp_rec->Quantity 
                     >> temp_rec->Receive_Date.day >> temp_rec->Receive_Date.month >> temp_rec->Receive_Date.year)
           {
                  loaded = true;
                  
                  
                  //remove "+" sign from book name and replace with spaces
                  for(int i=0; i<tName.length(); ++i)
                  {
                      if(tName[i]=='+') tName[i] = ' ';
                  }
                  
                  strcpy(temp_rec->Name, tName.c_str()); //add name to strcu record
                  
                  
                     
                  if(Head==NULL)
                  {
                       Head = temp_rec;         
                       temp_rec->Next = NULL;
                       Last = temp_rec;
                  }
                  
                  else
                  {
                      Last->Next = temp_rec;
                      temp_rec->Next = NULL;
                      Last = temp_rec;
                  }
                  
                  temp_rec = NULL;
                  temp_rec = new Node;
                  temp_rec->ID = -1000; //test if this new Node was use or wasn't use as there was no other record to load
           }                      
           
           
           fin.close();
     }
     
     delete temp_rec;
     temp_rec = NULL;
     
     if(loaded)
     {
               cout << "Database Loaded!" << endl << "Press any Key to proceed";
               system("pause>nul");
     }
     
}

//========================//
//    TERMINATION POINT
//========================//