//  Project 2 for CS 1704 Spring 2004
//
//  Programmer:    Phil Wallace
//  OS:            Windows XP Professional
//  System:        Pentium 4 2200, 768 MB Memory
//  Compiler:      Visual C++ .NET
//  Last modified: February 22, 2004
//
//  Purpose:
//	The purpose of this class is to implement the commands for the commands
//  that are requested in this organizer


/*
On my honor:

- I have not discussed the C++ language code in my program 
with anyone other than my instructor or the teaching assistants assigned to this course.

- I have not used C++ language code obtained from another student, or any other 
unauthorized source, either modified or unmodified. 

- If any C++ language code or documentation used in my program was obtained from 
another source, such as a textbook or course notes, that has been clearly noted 
with a proper citation in the comments of my program.

- I have not designed this program in such a way as to defeat or interfere with the 
normal operation of the Curator System.

Phil Wallace*/

#include "storage.h"

storage::storage()
{
	ofstream outFile;	//open and close output file
	outFile.open("output.data");
	outFile.close();

	string idata, sdata;	//data for the two files
	int Idx = 0;	//index of array
	bool FOUND = false;	//target flag
	ifstream studFile("students.data");		//student file stream
	assert(!studFile.fail());	//kicks out of the program if the file fails

	ifstream itemFile("items.data");		//item file stream
	assert(!itemFile.fail());	//kicks out of the program if the file fails

	while(getline(studFile, sdata))
	{
		set_student(sdata,Idx,studFile);	//input all student records
	}

	Idx = 0;	//reset index
	while(getline(itemFile,sdata))
	{
		set_student(sdata,Idx,itemFile);	//input all items
	}

	for(int x = 0; x < 100; x++)	//loop through istorage
	{
		for(int y = 0; y < 100; y++)	//loop through sstorage
		{
			if(sstorage[y].get_email().compare(istorage[x].get_owner()) == 0) //if a student record match is found
			{
				FOUND = true;	//is found
				break;	//skip out of loop
			}
		}

		if(!FOUND)
		{
			istorage[x].set_owner(""); //"delete" entry by setting owner to ""
		}
		FOUND = false;	//reset FOUND
	}

	studFile.close();	//close files
	itemFile.close();
}

//////////////////////////////////////////////////////////////// compare
// returns an "integerized" conversion from a string to use in switch statements
//
// Parameters:
//		data - string containing field conversion
//
// Pre:       must be called by storage constructor
// Post:      "converts" data field to an int
//
// Returns:   integer for use in swith statement
//
// Called by: storage::storage
// Calls:     nothing
//

int storage::compare(string data)
{
	if(data.compare("@Name:") == 0) //name field
		return 0;

	else if(data.compare("@Phone Number:") == 0)	//phone number field
		return 1;

	else if(data.compare("@E-mail:") == 0)	//email field
		return 2;

	else if(data.compare("@Address Line 1:") == 0)	//Address Line 1
		return 3;

	else if(data.compare("@Address Line 2:") == 0)	//Address Line 2
		return 4;

	else if(data.compare("@City:") == 0)	//City field
		return 5;

	else if(data.compare("@State:") == 0)	//state field
		return 6;

	else if(data.compare("@Zipcode:") == 0)		//zip code field
		return 7;

	else if(data.compare("@Other:") == 0)	//other comments field
		return 8;

	else if(data.compare("@Item:") == 0)	//Item field
		return 9;

	else if(data.compare("@Media Type:") == 0)	//Media type field
		return 10;

	else if(data.compare("@by:") == 0)	//author field
		return 11;

	else if(data.compare("@Owner:") == 0)	//author field
		return 12;

	else if(data.compare("@Price:") == 0)	//price field
		return 13;

	else if(data.compare("@Availability:") == 0)	//availibility field
		return 14;

	else if(data.compare("@@") == 0)	//end object
		return 15;

	else
		return 16;	//will generate an error message in switch
}

//////////////////////////////////////////////////////////////// set_student
// sets fields inside an object
//
// Parameters:
//		sdata - string containing field
//		index - index of slot to modify
//		myFile - file stream
//
// Pre:       myFile must open successfully
// Post:      sets one field in an object
//
// Returns:   nothing
//
// Called by: add_student, add_item
// Calls:     compare
//

void storage::set_student(string sdata, int &index, istream& myFile)
{
	switch(compare(sdata))	//inputs student data
		{
			case 0:	getline(myFile,sdata);
					sstorage[index].set_name(sdata);	//set name
					break;
					
			case 1: getline(myFile,sdata);
					sstorage[index].set_phone(sdata);	//set phone number
					break;

			case 2: getline(myFile,sdata);
					sstorage[index].set_email(sdata);	//set email address
					break;

			case 3: getline(myFile,sdata);
					sstorage[index].set_add1(sdata);	//add address 1
					break;

			case 4:	getline(myFile,sdata);
					sstorage[index].set_add2(sdata);	//add address 2
					break;

			case 5:	getline(myFile,sdata);
					sstorage[index].set_city(sdata);	//add city
					break;
					
			case 6:	getline(myFile,sdata);
					sstorage[index].set_state(sdata);	//add state
					break;

			case 7:	getline(myFile,sdata);
					sstorage[index].set_zip(sdata);		//add zip code
					break;

			case 8:	getline(myFile,sdata);
					sstorage[index].set_other(sdata);	//add other field
					break;

			case 9:	getline(myFile,sdata);
					istorage[index].set_name(sdata);	//set item name
					break;

			case 10:getline(myFile,sdata);
					istorage[index].set_media(sdata);	//set media type
					break;
					
			case 11:getline(myFile,sdata);
					istorage[index].set_author(sdata);	//set author of media
					break;

			case 12:getline(myFile,sdata);
					istorage[index].set_owner(sdata);	//set owner of media
					break;

			case 13:getline(myFile,sdata);
					istorage[index].set_price(sdata);	//set price of media
					break;

			case 14:getline(myFile,sdata);
					istorage[index].set_avail(sdata);	//set availability
					break;

			case 15:index++;	//increment Idx to next slot
					getline(myFile,sdata); //eliminate next space
					break;

			default:	cout<<"Bad field in students.data"<<endl;	//spits out error and exits semi-gracefully
						exit(1);
		}
}

//////////////////////////////////////////////////////////////// print_students
// prints all student records
//
// Parameters:
//		none
//
// Pre:       none
// Post:      prints student records
//
// Returns:   nothing
//
// Called by: read_commands
// Calls:     nothing
//

void storage::print_students()
{
	ofstream outFile;	//data file
	outFile.open("output.data",ios::app);

	outFile<<"print students"<<endl;	//print command

	for(int x = 0; x < 100; x++)
	{
		if(sstorage[x].get_email().compare("") == 0) //no email length means blank spot
            continue;

		if(!(sstorage[x].get_name().compare("") == 0))	//output name
		{
			outFile<<"Name:"<<endl;
			outFile<<"\t"<<sstorage[x].get_name()<<endl;
		}
		
		if(!(sstorage[x].get_phone().compare("") == 0))	//output phone
		{
			outFile<<"Phone Number:"<<endl;
			outFile<<"\t"<<sstorage[x].get_phone()<<endl;
		}

		outFile<<"Email:"<<endl;	//output E-mail
		outFile<<"\t"<<sstorage[x].get_email()<<endl;

		if((!(sstorage[x].get_add1().compare("") == 0)) || (!(sstorage[x].get_add2().compare("") == 0)) ||
			   (!(sstorage[x].get_city().compare("") == 0)) || (!(sstorage[x].get_state().compare("") == 0))||
			   (!(sstorage[x].get_zip().compare("") == 0)))	//output address
			{
				outFile<<"Address:"<<endl;
				if(!(sstorage[x].get_add1().compare("") == 0))
				{
					outFile<<"\t"<<sstorage[x].get_add1()<<endl;
				}
				if(!(sstorage[x].get_add2().compare("") == 0))
				{
                    outFile<<"\t"<<sstorage[x].get_add2()<<endl;
				}
				if((!(sstorage[x].get_city().compare("") == 0)) || (!(sstorage[x].get_state().compare("") == 0)) ||
					(!(sstorage[x].get_zip().compare("") == 0)))
				{
					outFile<<"\t";
				}
				if(!(sstorage[x].get_city().compare("") == 0))
				{
					outFile<<sstorage[x].get_city();
				}
				if((!(sstorage[x].get_city().compare("") == 0)) && ((!(sstorage[x].get_state().compare("") == 0))||
					(!(sstorage[x].get_zip().compare("") == 0))))
				{
					outFile<<", ";
				}
				if(!(sstorage[x].get_state().compare("") == 0))
				{
					outFile<<sstorage[x].get_state()<<" ";
				}
				if(!(sstorage[x].get_zip().compare("") == 0))
				{
					outFile<<sstorage[x].get_zip();
				}
				outFile<<endl;
			}
		if(!(sstorage[x].get_other().compare("") == 0))	//output other comments
		{
			outFile<<"Other:"<<endl;
			outFile<<"\t"<<sstorage[x].get_other()<<endl;
		}

		outFile<<endl;	//separate students
	}
	outFile<<endl;
	outFile.close();
}

//////////////////////////////////////////////////////////////// print_items
// prints all items
//
// Parameters:
//		none
//
// Pre:       none
// Post:      prints items in list
//
// Returns:   
//
// Called by: read_commands
// Calls:     nothing
//

void storage::print_items()
{
	ofstream outFile;	//open output file
	outFile.open("output.data",ios::app);

	outFile<<"print items"<<endl;

	for(int x = 0; x < 100; x++)
	{
		if(istorage[x].get_owner().compare("") == 0) //no email length means blank spot
            continue;

		if(!(istorage[x].get_name().compare("") == 0))	//output item
		{
			outFile<<"Item:"<<endl;
			outFile<<"\t"<<istorage[x].get_name()<<endl;
		}
		
		if(!(istorage[x].get_media().compare("") == 0))	//output media type
		{
			outFile<<"Media Type:"<<endl;
			outFile<<"\t"<<istorage[x].get_media()<<endl;
		}

		if(!(istorage[x].get_author().compare("") == 0))	//output author
		{
			outFile<<"by:"<<endl;
			outFile<<"\t"<<istorage[x].get_author()<<endl;
		}

		outFile<<"Owner:"<<endl;
		outFile<<"\t"<<istorage[x].get_owner()<<endl;	//output owner

		if(!(istorage[x].get_price().compare("") == 0))	//output price
		{
			outFile<<"Price:"<<endl;
			outFile<<"\t"<<istorage[x].get_price()<<endl;
		}

		if(!(istorage[x].get_avail().compare("") == 0))	//output availability
		{
			outFile<<"Availability:"<<endl;
			outFile<<"\t"<<istorage[x].get_avail()<<endl;
		}
		outFile<<endl;	//separate entries
		
	}

	outFile<<endl;	//close file
	outFile.close();
}
//////////////////////////////////////////////////////////////// print_email
// prints a student record, plus all items with student
//
// Parameters:
//		email - student's email
//
// Pre:       email must not be ""
// Post:      prints student and all items if it exists
//
// Returns:   nothing
//
// Called by: read_commands
// Calls:     nothing
//

void storage::print_email(string email)
{
	ofstream outFile;	//open output file
	outFile.open("output.data",ios::app);

	outFile<<"print "<<email<<endl;

	bool FOUND = false;	//boolean flag

	for(int x = 0; x < 100; x++)
	{
		if(sstorage[x].get_email().compare(email)== 0)
		{
			if(!(sstorage[x].get_name().compare("") == 0))	//output name
			{
				outFile<<"Name:"<<endl;
				outFile<<"\t"<<sstorage[x].get_name()<<endl;
			}
		
			if(!(sstorage[x].get_phone().compare("") == 0))	//output phone
			{
				outFile<<"Phone Number:"<<endl;
				outFile<<"\t"<<sstorage[x].get_phone()<<endl;
			}

			outFile<<"Email:"<<endl;
			outFile<<"\t"<<sstorage[x].get_email()<<endl;	//output owner

			if((!(sstorage[x].get_add1().compare("") == 0)) || (!(sstorage[x].get_add2().compare("") == 0)) ||
			   (!(sstorage[x].get_city().compare("") == 0)) || (!(sstorage[x].get_state().compare("") == 0))||
			   (!(sstorage[x].get_zip().compare("") == 0)))	//output address
			{
				outFile<<"Address:"<<endl;
				if(!(sstorage[x].get_add1().compare("") == 0))
				{
					outFile<<"\t"<<sstorage[x].get_add1()<<endl;
				}
				if(!(sstorage[x].get_add2().compare("") == 0))
				{
                    outFile<<"\t"<<sstorage[x].get_add2()<<endl;
				}
				if((!(sstorage[x].get_city().compare("") == 0)) || (!(sstorage[x].get_state().compare("") == 0)) ||
					(!(sstorage[x].get_zip().compare("") == 0)))
				{
					outFile<<"\t";
				}
				if(!(sstorage[x].get_city().compare("") == 0))
				{
					outFile<<sstorage[x].get_city();
				}
				if((!(sstorage[x].get_city().compare("") == 0)) && ((!(sstorage[x].get_state().compare("") == 0))||
					(!(sstorage[x].get_zip().compare("") == 0))))
				{
					outFile<<", ";
				}
				if(!(sstorage[x].get_state().compare("") == 0))
				{
					outFile<<sstorage[x].get_state()<<" ";
				}
				if(!(sstorage[x].get_zip().compare("") == 0))
				{
					outFile<<sstorage[x].get_zip();
				}
				outFile<<endl;
			}

			if(!(sstorage[x].get_other().compare("") == 0))	//output other comments
			{
				outFile<<"Other:"<<endl;
				outFile<<"\t"<<sstorage[x].get_other()<<endl<<endl;
			}
			
			FOUND = true;	//flag for found

			break;
		}		
	}

	if(!FOUND)
	{
		outFile<<email<<" not found."<<endl;	//tells file not found
		return;
	}

	for(int y = 0; y < 100; y++)
	{
		if(istorage[y].get_owner().compare(email)== 0)
		{
			if(!(istorage[y].get_name().compare("") == 0))	//output item
			{
				outFile<<endl<<"Item:"<<endl;
				outFile<<"\t"<<istorage[y].get_name()<<endl;
			}
			
			if(!(istorage[y].get_media().compare("") == 0))	//output media type
			{
				outFile<<"Media Type:"<<endl;
				outFile<<"\t"<<istorage[y].get_media()<<endl;
			}
	
			if(!(istorage[y].get_author().compare("") == 0))	//output author
			{
				outFile<<"by:"<<endl;
				outFile<<"\t"<<istorage[y].get_author()<<endl;
			}

			if(!(istorage[y].get_price().compare("") == 0))	//output price
			{
				outFile<<"Price:"<<endl;
				outFile<<"\t"<<istorage[y].get_price()<<endl;
			}

			if(!(istorage[y].get_avail().compare("") == 0))	//output availability
			{
				outFile<<"Availability:"<<endl;
				outFile<<"\t"<<istorage[y].get_avail()<<endl<<endl;
			}
		}
	}
	outFile.close();
}

//////////////////////////////////////////////////////////////// add_item
// adds one item to the lists
//
// Parameters:
//		data - string containing field 
//		File - data file stream
//
// Pre:       none
// Post:      adds one item

// Returns:   nothing
//
// Called by: read_commands
// Calls:     set_field
//

void storage::add_item(string data, istream &File)
{
	ofstream outFile;	//open output file
	outFile.open("output.data",ios::app);
	bool FOUND = false;

	int Idx = 0;	//placeholder Index

	outFile<<"add item"<<endl;

	for(int x = 0; x < 100; x++)
	{
		if(istorage[x].get_owner().compare("") == 0)	//find an empty slot
		{
			istorage[x].icleanup();
			getline(File, data);
			while(!(data == "@@"))
			{
				set_student(data,x,File);	//add data
				getline(File, data);
			}
			Idx = x;	//for failure checking
			
			for(int y = 0; y < 100; y++)
			{
				if((istorage[y] == istorage[x]) && (y != x))
				{
					istorage[x].icleanup();
				}
			}
		
			for(int z = 0; z < 100; z++)
			{
				if((sstorage[z].get_email() == istorage[x].get_owner()))
				{
					FOUND = true;
				}
				if((sstorage[z].get_email() == istorage[x].get_owner())) break;	
			}
			
			break;
		}
	}

	if((istorage[Idx].get_owner().compare("") == 0) || (!FOUND))	//if email is empty, fail
	{
		istorage[Idx].icleanup();
		outFile<<"Failure"<<endl;
		outFile.close();
		return;
	}

	outFile<<"Success"<<endl;
	outFile.close();
}


//////////////////////////////////////////////////////////////// add_student
// adds one student to the lists
//
// Parameters:
//		data - string containing field 
//		File - data file stream
//
// Pre:       none
// Post:      adds one student

// Returns:   nothing
//
// Called by: read_commands
// Calls:     set_student
//

void storage::add_student(string data, istream &File)
{
	ofstream outFile;	//open output file
	outFile.open("output.data",ios::app);

	int Idx = 0;	//placeholder Index

	outFile<<"add student"<<endl;

	for(int x = 0; x < 100; x++)	//find an empty slot
	{
		if(sstorage[x].get_email().compare("") == 0)
		{
			sstorage[x].scleanup();
			getline(File, data);
			while(!(data == "@@"))
			{
				set_student(data,x,File);	//add data
				getline(File, data);
			}
			Idx = x;	//for failure checking

			for(int y = 0; y < 100; y++)
			{
				if((sstorage[y] == sstorage[x]) && (y != x))
				{
					sstorage[x].set_email("");
				}
			}
			break;
		}
	}

	if(sstorage[Idx].get_email().compare("") == 0)	//if no email, fail
	{
		outFile<<"Failure"<<endl;
		outFile.close();
		return;
	}

	outFile<<"Success"<<endl;
	outFile.close();
}


//////////////////////////////////////////////////////////////// delete_email
// deletes a student and all items
//
// Parameters:
//		email - student email
//
// Pre:       email must not be ""
// Post:      deletes student and all items

// Returns:   nothing
//
// Called by: read_commands
// Calls:     nothing
//

void storage::delete_email(string email)
{
	ofstream outFile;	//open output file
	outFile.open("output.data",ios::app);
	bool FOUND = false;		//found flag

	outFile<<"delete "<<email<<endl;	//output command

	for(int x = 0; x < 100; x++)	//loop through sstorgage looking for proper email
	{
		if(sstorage[x].get_email().compare(email) == 0)
		{
			sstorage[x].scleanup();
			//sstorage[x].set_email("");	//delete record
			FOUND = true;
		}
	}

	if(!FOUND)	//if not found 
	{
		outFile<<"Failure"<<endl;	//output failure
		return;
	}
	
	for(int y = 0; y < 100; y++)
	{
		if(istorage[y].get_owner().compare(email) == 0)	//loop through until owner email found
		{
			istorage[y].icleanup();
			//istorage[y].set_owner("");	//"delete" entry
		}
	}
	outFile<<"Success"<<endl;	//output success

	outFile.close();	//close file
}