#include "stdafx.h"
#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <string>
using namespace std;

// struct definition for even number linked list node
struct ListNode
{
	ListNode () 
	{ 
		Next = NULL;
		Prev = NULL;
	}

	int Num;
	
	ListNode* Next;		
	ListNode* Prev;											
};

// function prototypes
bool ValidateFiles (int argc, char* argv [], ifstream& file_A, ifstream& file_B);
void WelcomeMessage ();
void AddToEndOfList (ListNode*& evenHead, ListNode* tmp);
bool ValidateUniqueNumbers (ListNode* evenHead, int search);
ListNode* SearchListForNumbers (int search, ListNode*& evenHead);
void DisplayResults (ListNode* oddHead, ListNode* evenHead);

//*************************************************************************
//  FUNCTION: main
//  DESCRIPTION:  Calls functions in order to read files, store data, search
//				  for data, and print results for user
//  CALLS TO: ValidateFiles, WelcomeMessage, AddToEndOfList,
//			  ValidateUniqueNumbers, SearchListForNumbers, DisplayResults
//*************************************************************************
int main (int argc, char* argv [])
{
	int search = 0;															// results of search
	ListNode* evenHead = NULL;												// pointer for head node in even list
	ListNode* oddHead = NULL;												// pointer for head node in odd list
	int count = 0;															// counter for display
	ifstream file_A;														// intput file - file_A (should be listnums.txt)
	ifstream file_B;														// intput file - file_B (should be findthem.txt)

	WelcomeMessage ();														// function call

	// if files are valid
	if (!ValidateFiles (argc, argv, file_A, file_B))							// function call
	{
		// while file is good, and data is still available
		while (file_A.good () && file_A.peek () != EOF)						
		{
			// create new node
			ListNode* tmp = new ListNode ();

			// read in data from file_A
			file_A >> tmp -> Num;		
	
			// determine if int is even
			if (tmp -> Num % 2 == 0)
			{
				if (!ValidateUniqueNumbers (evenHead, tmp -> Num))			// function call
				{
					// if number is unique, add to list
					AddToEndOfList (evenHead, tmp);
				}
			}
			// if not even
			else
			{
				if (!ValidateUniqueNumbers (oddHead, tmp -> Num))			// function call
				{
					// if number is unique, add to list
					AddToEndOfList (oddHead, tmp);
				}
			}
		}
	
		DisplayResults (oddHead, evenHead);									// function call - display results of stored numbers
	
		// while file is good, and data is available
		while (file_B.good () && file_B.peek () != EOF)
		{
			// read data from file_B
			file_B >> search;
	
			// if int is even
			if (search % 2 == 0)
			{
				// determine where in list each number is
				ListNode* result = SearchListForNumbers (search, evenHead);	// function call
			
				// if number is found
				if (result != NULL)
				{
					// determine count for placement in list, and output
					for (ListNode* iter = evenHead; iter != result; iter = iter -> Next)
					{
						count++;
						cout << search << " found " << count << " number(s) down in the even list" << endl;
					}
				}
				// if not found
				else
				{
					cout << search << " not found in even list" << endl;
				}
			}
			// if not even
			else
			{
				// determine where in list number is
				ListNode* result = SearchListForNumbers (search, oddHead);	// function call
					
				// if number is found
				if (result != NULL)
				{
					// determine count for placement in list, and output
					for (ListNode* iter = oddHead; iter != result; iter = iter -> Next)
					{
						count++;
						cout << search << " found " << count << " number(s) down in the odd list" << endl;
					}
				}
				// if not found
				else
				{
					cout << search << " not found in odd list" << endl;
				}
			}
		}
	
		// pause for user to read, and exit gracefully
		system ("PAUSE");
		return 0;
	}
	// if files are not valid
	else
	{
		// exit program
		system ("PAUSE");
		return 1;
	}
}

//*********************************************************************
//  FUNCTION: WelcomeMessage
//  DESCRIPTION: displays welcome message
//  INPUT:
//      Parameters: none
//      File: none
//  OUTPUT:
//      Return Val: none
//      Parameters: none
//      File: none
//  CALLS TO: none
//**********************************************************************
void WelcomeMessage() 
{
	// display welcome message to user
	cout << "Double Linked List Program" << endl;
}// end WelcomeMessage

//*********************************************************************
//  FUNCTION: ValidateFiles
//  DESCRIPTION: function validates program and files entered by user
//  INPUT:
//      Parameters: argc, argv
//      File: none
//  OUTPUT:
//      Return Val: quit
//      Parameters: none
//      File: none
//  CALLS TO: none
//**********************************************************************
bool ValidateFiles (int argc, char* argv [], ifstream& file_A, ifstream& file_B) 
{
	bool quit = false;

	// if enough files are not passed by user, exit
	if (argc != 3)
	{
		cout << "You have not specified the correct number of files!" << endl;
		quit = true;
	}
	// open files and validate
	else
	{
		ifstream file_A (argv [1]);

		if (!file_A.is_open ())
		{
			cout << "Could not open file " << argv [1] << endl;
			quit = true;
		}

		ifstream file_B (argv [2]);

		if (!file_B.is_open ())
		{
			cout << "Could not open file " << argv [2] << endl;
			quit = true;
		}
	}
	
	return quit;
}// end ValidateFiles

//*********************************************************************
//  FUNCTION: AddToEndOfList
//  DESCRIPTION: function adds numbers to appropriate linked lists
//  INPUT:
//      Parameters: evenHead, tmp
//      File: none
//  OUTPUT:
//      Return Val: none
//      Parameters: evenHead
//      File: none
//  CALLS TO: none
//**********************************************************************
void AddToEndOfList (ListNode*& evenHead, ListNode* tmp)
{
	// if head node for even list is empty
	if (evenHead == NULL)
	{	
		// head node is tmp node
		evenHead = tmp;
	}
	else
	{
		// iterate through file_A until all unique numbers have been added
		ListNode* iter = evenHead;
		
		while (iter -> Next != NULL)
		{
			iter = iter -> Next;
		}

		iter -> Next = tmp;
		tmp -> Prev = iter;
	}
}// end AddToEndOfList
//*********************************************************************
//  FUNCTION: ValidateUniqueNumbers
//  DESCRIPTION: function determines whether integer already exists to 
//				 prepare for add
//  INPUT:
//      Parameters: evenHead, search
//      File: none
//  OUTPUT:
//      Return Val: none
//      Parameters: evenHead
//      File: none
//  CALLS TO: none
//**********************************************************************
bool ValidateUniqueNumbers (ListNode* evenHead, int search)
{
	bool result = false;													// bool variable for whether the number was found
	
	// if head node is empty
	if (evenHead != NULL)
	{
		ListNode* iter = evenHead;

		// iterate through to search entire record
		while (iter -> Next != NULL && !result)
		{
			// if found
			if ( iter -> Num == search)
			{
				result = true;
			}
			// if not found
			else
			{
				iter = iter -> Next;
			}
		}

		// final search
		if (iter -> Num == search)
		{
			result = true;
		}
	}

	return result;
}// end ValidateUniqueNumbers

//*********************************************************************
//  FUNCTION: SearchListForNumbers
//  DESCRIPTION: function uses numbers from file_B to search for in file_A
//  INPUT:
//      Parameters: search, evenHead
//      File: none
//  OUTPUT:
//      Return Val: none
//      Parameters: evenHead
//      File: none
//  CALLS TO: none
//**********************************************************************
ListNode* SearchListForNumbers (int search, ListNode*& evenHead)
{
	// if list is empty, return NULL
	if (evenHead == NULL)
	{
		return NULL;
	}

	ListNode* iter = evenHead;
	
	bool found = false;
	
	// while there are records available
	while (iter -> Next != NULL && !found) 
	{
		if (iter -> Num != search)
		{
			iter = iter -> Next;
		}
		// or claim found
		else 
		{
			found = true;
		}
	}

	//check last record
	if (!found && iter -> Num != search)
	{
		// not found in list
		return NULL;
	} 
	else
	{
		// return found info
		return iter;
	}
}// end SearchListForNumbers