#include "Header.h"
#include "Organizer.h"

// student class functions
//////////////////////////////////////////////////////////////// <Student>
// this functions sets the default values of the variables
// Parameters: none
//
// Returns:   nothin
//
// Called by: class student
// Calls:  
Student::Student()
{
	string bnk = "blank";				// default value
	name = bnk;
	phone= bnk;
	email = bnk;
	address1 = bnk;
	address2 = bnk;
	city = bnk;
	state =  bnk;
	zip =bnk;
	other=bnk;
}
// updates the value of name
void Student::update_name( string name1 )
{
	name = name1;
}
// updates the value of phone
void Student::update_phone( string phone1 )
{
	phone = phone1;
}
// updates the value of email
void Student::update_email( string email1 )
{
	email = email1;
}
// updates the value address1
void Student::update_address1( string address1a )
{
	address1 = address1a;
}
// updates the value of address2
void Student::update_address2( string address2a )
{
	address2 = address2a;
}
// updates the value of city
void Student::update_city( string city1 )
{
	city = city1;
}
// updates the value of state
void Student::update_state( string state1 )
{
	state = state1;
}
// updates the value of zip
void Student::update_zip( string zip1 )
{
	zip = zip1;
}
//updates the value of other
void Student::update_other( string other1 )
{
	other = other1;
}
// returns the value of name
string Student::access_name(Student std)
{
	string temp;
	temp = std.name;
	return temp;
}
// returns the value of phone
string Student::access_phone(Student std)
{
	string temp;
	temp = std.phone;
	return temp;
}
// returns the value of email
string Student::access_email( Student std )
{
	string temp;
	temp = std.email;
	return temp;
}
// returns the value of address1
string Student::access_address1(Student std)
{
	string temp;
	temp = std.address1;
	return temp;
}
// returns the value of address2
string Student::access_address2(Student std)
{
	string temp;
	temp = std.address2;
	return temp;
}
// returns the value of city
string Student::access_city(Student std)
{
	string temp;
	temp = std.city;
	return temp;
}
// returns the value of state
string Student::access_state(Student std)
{
	string temp;
	temp = std.state;
	return temp;
}
// returns the value of zip
string Student::access_zip(Student std)
{
	string temp;
	temp = std.zip;
	return temp;
}
// returns the value of other
string Student::access_other(Student std)
{
	string temp;
	temp = std.other;
	return temp;
}

// multimedia class functions
//////////////////////////////////////////////////////////////// <Multimedia>
// <this function sets teh default values for the multimedia class
// Parameters:none
//
// Returns:   nothin
//
// Called by: multimedia class
// Calls: 
Multimedia::Multimedia()
{
	string bnk = "blank";
	item = bnk;				// data members
	media= bnk;
	by= bnk;
	owner= bnk;
	price= bnk;
	avail= bnk;
}
void Multimedia::update_item( string item1 )
{
	item = item1;
}

void Multimedia::update_media( string media1 )
{
	media = media1;
}

void Multimedia::update_by( string by1 )
{
	by = by1;
}

void Multimedia::update_owner( string owner1 )
{
	owner = owner1;
}

void Multimedia::update_price( string price1 )
{
	price = price1;
}

void Multimedia::update_avail( string avail1 )
{
	avail = avail1;
}

string Multimedia::access_item(Multimedia multi)
{
	string temp;
	temp = multi.item;
	return temp;
}

string Multimedia::access_media(Multimedia multi)
{
	string temp;
	temp = multi.media;
	return temp;
}

string Multimedia::access_by(Multimedia multi)
{
	string temp;
	temp = multi.by;
	return temp;
}

string Multimedia::access_owner(Multimedia multi)
{
	string temp;
	temp = multi.owner;
	return temp;
}

string Multimedia::access_price(Multimedia multi)
{
	string temp;
	temp = multi.price;
	return temp;
}

string Multimedia::access_avail(Multimedia multi)
{
	string temp;
	temp = multi.avail;
	return temp;
}


// organizer class functions
//////////////////////////////////////////////////////////////// <Organizer>
// <this function sets the default values for the data members
// and fills the arrays w/ dummie objects
// Parameters:	none
//		
// Returns:   nothing
//
// Called by: Organizer class
// Calls:  
Organizer::Organizer ()
{
	Student std;								// student type
	Multimedia multi;							// multimedia type
	int i=0, x=0;								// variable guys
	string bnk = "blank";						// default string

	std.update_name(bnk);						// sets to default values
	std.update_phone(bnk);
	std.update_email( bnk );	
	std.update_address1(bnk);
	std.update_address2(bnk);
	std.update_city(bnk);
	std.update_state(bnk);
	std.update_zip( bnk);
	std.update_other(bnk);

	multi.update_item( bnk );					// fills w/ default values
	multi.update_media(bnk);
	multi.update_by( bnk );
	multi.update_owner( bnk );
	multi.update_price( bnk );
	multi.update_avail( bnk );

	while( i < 100 )							// fills the array for student objects
	{											// w/ dummie values
		array[i] = std;
		i++;
	}

	while( x < 100 )							// fills the array for multimedia objects
	{											// w/ dummie values
		array1[x] = multi;
		x++;
	}

	count = 0;							// sets default variables to zero
	count1 = 0;
	deleted = 0;
	deleted1=0;
	add=0;
	add1=0;
}

//////////////////////////////////////////////////////////////// <print_email>
// <this function accepts an email address and prints all student objects 
// and multimedia objects that contain that email address.
//
// Parameters:
//		string email = email address
//		ofstream outfile- the output file to print to
//
// Returns:   bool- returns true or false
//
// Called by: command
// Calls:  
bool Organizer::print_email( string email, ofstream &outfile )
{
	Student std;						// student type
	Multimedia multi;					// multimedia type
	string bnk = "blank";				// default string
	string name1;						// variables declaration
	string email1;
	string phone1;
	string address1a;
	string address2a;
	string city1;
	string state1;
	string zip1;
	string other1;
	
	string item1;						// variables for item types
	string media1;	
	string by1;
	string owner1;
	string price1;
	string avail1;
	string email2;
	bool tru = false;					// bool set to false

	int i=0, x=0;
	while ( i < 100 )					// while i is less than 100
	{									// 100 = max size of the array
		std = array[i];					// get an object from the array
		email1 = std.access_email(std);	// get that objects email address
		
		if( email1 == email )			// if the email address is the same as
		{								// the one passed
			tru = true;					// boolean = true
			name1 = std.access_name(std);			// get: name of the object
			phone1 = std.access_phone(std );		// phone # of object
			address1a = std.access_address1(std);	// address of the object
			address2a = std.access_address2(std);	// apartment of the object
			city1 = std.access_city(std);			// city of the object
			state1 = std.access_state(std);			// state of the object
			zip1 = std.access_zip( std );			// zip of the object
			other1 = std.access_other( std );		// and other string
			
			if( name1 != bnk )						// only print a strin if its not 
			{										// set to default
				outfile << "Name:\n ";				// output command
				outfile << name1 << endl;			// output string
			}
			if( phone1 != bnk )
			{
				outfile << "Phone Number:\n ";
				outfile << phone1 << endl;
			}
			if( email1 != bnk )
			{
				outfile << "Email:\n ";
				outfile << email1 << endl;
			}
			if( address1a!=bnk || address2a!=bnk || city1!=bnk || state1!=bnk || zip1!=bnk )
			{										// this sets up the addresses the right way
				outfile << "Address:\n";			// instead of outputting them seperatly
				if( address1a != bnk )				// outputs it the way u see it on a letter
					outfile << " " << address1a << endl;
				if( address2a != bnk )
					outfile << " " << address2a << endl;
				if( city1 != bnk && state1 != bnk && zip1!=bnk )						// this set considers all possibilites 
					outfile << " " << city1 << ", " << state1 << " " << zip1 << endl;	// of outputtin city, state, and zip
				else if( city1 != bnk && state1 != bnk && zip1==bnk )
					outfile << " " << city1 << ", " << state1 << endl;
				else if( city1 != bnk && state1 == bnk && zip1 !=bnk )
					outfile << " " << city1 << ", " << zip1 << endl;
				else if( city1 == bnk && state1 != bnk && zip1 != bnk )
					outfile << " " << state1 << " " << zip1 << endl;
				else if( city1 != bnk )
					outfile << " " << city1 << endl;
				else if( state1 != bnk )
					outfile << " " << state1 << endl;
				else if( zip1 != bnk )
					outfile << " " << zip1 << endl;
			}
			if( other1 != bnk )
			{
				outfile << "Other:\n ";
				outfile << other1 << endl;
			}
		}
		i++;
	}
	if( tru == false )								// if nothing is there
		return false;								// return false
	while( x < 100 )								// prints the multimedia objects
	{
		
		multi = array1[x];							// gets object
		email2 = multi.access_owner( multi );		// stores string from object
		
		if( email2 == email )						// if emails are equal
		{											// prints the items
			outfile << endl;
			tru = true;
			item1 = multi.access_item( multi );
			media1 = multi.access_media( multi );
			by1 = multi.access_by( multi );
			owner1 = multi.access_owner( multi );
			price1 = multi.access_price( multi );
			avail1 = multi.access_avail( multi );

			if( item1 != bnk )
			{
				outfile << "Item:\n ";
				outfile << item1 << endl;
			}
			if( media1 != bnk )
			{
				outfile << "Media Type:\n ";
				outfile << media1 << endl;
			}
			if( by1 != bnk )
			{
				outfile << "by:\n ";
				outfile << by1 << endl;
			}
			if( price1 != bnk )
			{
				outfile << "Price:\n ";
				outfile << price1 << endl;
			}
			if( avail1 != bnk )
			{
				outfile << "Availability:\n ";
				outfile << avail1 << endl;
			}
		}
		x++;

	}

	if( tru == false )						// if still = to false
	{
		return false;						// return false nothing was present
	}
	else									// otherwise
	{
		outfile << endl;					// output new like
		return true;						// return true
	}
}

//////////////////////////////////////////////////////////////// <print_students>
// <this function prints all student objects that are stored in array
//	by the order they were added to the array
//
// Parameters:
//		ofstream outfile- the output file to print to
//
// Returns:   bool- returns true or false
//
// Called by: command
// Calls: 
bool Organizer::print_students( ofstream &outfile )
{
	int i=0;										// variable declaration
	Student std;
	string bnk = "blank";
	string name1;
	string email1;
	string phone1;
	string address1a;
	string address2a;
	string city1;
	string state1;
	string zip1;
	string other1;
	bool tru = false;

	while ( i < count )								// while i is less then the number
	{												// of objects in the array
		std = array[i];								// get the student object
		
		tru = true;
		email1 = std.access_email(std);				// gets email
		name1 = std.access_name(std);				// name
		phone1 = std.access_phone(std );			// phone number
		address1a = std.access_address1(std);		// address
		address2a = std.access_address2(std);		// apartment
		city1 = std.access_city(std);				// city
		state1 = std.access_state(std);				// state
		zip1 = std.access_zip( std );				// zip code
		other1 = std.access_other( std );			// and other informations string
		
		
		if( email1 != bnk )							// if email are = to eachother
		{
			if( name1 != bnk )						// output the anem
			{
				outfile << "Name:\n ";
				outfile << name1 << endl;
			}
			if( phone1 != bnk )						// output the phone numebr
			{
				outfile << "Phone Number:\n ";
				outfile << phone1 << endl;
			}
			if( email1 != bnk )						// output the email address
			{
				outfile << "Email:\n ";
				outfile << email1 << endl;
			}
			if( address1a!=bnk || address2a!=bnk || city1!=bnk || state1!=bnk || zip1!=bnk )
			{
				outfile << "Address:\n";
				if( address1a != bnk )
					outfile << " " << address1a << endl;
				if( address2a != bnk )
					outfile << " " << address2a << endl;
				if( city1 != bnk && state1 != bnk && zip1!=bnk )
					outfile << " " << city1 << ", " << state1 << " " << zip1 << endl;
				else if( city1 != bnk && state1 != bnk && zip1==bnk )
					outfile << " " << city1 << ", " << state1 << endl;
				else if( city1 != bnk && state1 == bnk && zip1 !=bnk )
					outfile << " " << city1 << ", " << zip1 << endl;
				else if( city1 == bnk && state1 != bnk && zip1 != bnk )
					outfile << " " << state1 << " " << zip1 << endl;
				else if( city1 != bnk )
					outfile << " " << city1 << endl;
				else if( state1 != bnk )
					outfile << " " << state1 << endl;
				else if( zip1 != bnk )
					outfile << " " << zip1 << endl;
			}
			if( other1 != bnk )
			{
				outfile << "Other:\n ";
				outfile << other1 << endl;
			}
			outfile << endl;
			
		}
		i++;													// increment the variable
	}
	if( tru == false )											// return true/false
		return false;
	else
		return true;
}

//////////////////////////////////////////////////////////////// <print_items>
// <this function prints all multimedia objects that are stored in array1
//
// Parameters:
//		ofstream outfile- the output file to print to
//
// Returns:   bool- returns true or false
//
// Called by: command
// Calls:  
bool Organizer::print_items( ofstream &outfile )
{
	int x=0;									// variable declaration
	Multimedia multi;
	string item1;
	string media1;
	string by1;
	string owner1;
	string price1;
	string avail1;
	string email2;
	bool tru = false;
	string bnk = "blank";
	while( x < count1 )							// while x is less then the #
	{											// of objects in array1
		
		multi = array1[x];						// get multimedia object

		tru = true;								// set tru to value of true
		item1 = multi.access_item( multi );		// get information from multimedia object
		media1 = multi.access_media( multi );
		by1 = multi.access_by( multi );
		owner1 = multi.access_owner( multi );
		price1 = multi.access_price( multi );
		avail1 = multi.access_avail( multi );

		if( owner1 != bnk )						// if object is set to default skip
		{
			if( item1 != bnk )
			{
				outfile << "Item:\n ";
				outfile << item1 << endl;
			}
			if( media1 != bnk )
			{
				outfile << "Media Type:\n ";
				outfile << media1 << endl;
			}
			if( by1 != bnk )
			{
				outfile << "by:\n ";
				outfile << by1 << endl;
			}
			if( owner1 != bnk )
			{
				outfile << "Owner:\n ";
				outfile << owner1 << endl;
			}
			if( price1 != bnk )
			{
				outfile << "Price:\n ";
				outfile << price1 << endl;
			}
			if( avail1 != bnk )
			{
				outfile << "Availability:\n ";
				outfile << avail1 << endl;
			}
			outfile << endl;
		}
		x++;									// incrememnt x
	}
	
	if( tru == false )							// return true/false
		return false;
	else
		return true;
}		

//////////////////////////////////////////////////////////////// <delete1>
// <this function accepts an email address and deletes all student and 
// multimedia objects w/ that email address from the array
//
// Parameters:
//		string email- passes the email address 
//
// Returns:   boolean- true/false
//
// Called by: command
// Calls:  
bool Organizer::delete1( string email )
{
	int i=0, dlt =0, x=0;				// variable declarations
	Student blank;						// blank student object
	Multimedia blank1;					// blank multi object
	bool tru;							// tru value
	string bnk = "blank";				// set default value

	tru = false;						

	string temp;
	string temp1;

	while( i < 100 )					// while i is less then 100
	{									// search through the array for student object to delete
		blank = array[i];
		temp = blank.access_email( blank );
		
		if( temp == email )				// if = to email address to delete
		{
			blank.update_email(bnk);	// set the email address to bnk = blank
			array[i] = blank;			// sets to default value
			deleted++;					// increment item deleted
			tru = true;
		}
		i++;							// increment i
	}
	 if( tru == false )					// if no items to delete return false
		return false;					// only can delete item if student info exists
	while( x < 100 )					// searches through array1 for multimedia objects
	{
		blank1 = array1[x];				
		temp1 = blank1.access_owner( blank1 );
		
		if( temp1 == email )
		{
			blank1.update_owner( bnk );
			array1[x] = blank1;
			deleted1++;
			tru = true;
		}
		x++;
	}
	if( tru == true )					// return true
		return true;
	else
		return false;					// if not successful returns false
}
/*
void Organizer::push_array( int i )
{

	while( i < 99 )
	{
		array[i] = array[i+1];
		i++;
	}

}

void Organizer::push_array1( int i )
{
	
	while( i < 99 )
	{
		array1[i] = array1[i+1];
		i++;
	}

}*/

//////////////////////////////////////////////////////////////// <update_array>
// this function accepts data from the student file and creates new student 
// objects. it then stores those object into array for safe keeping
//
// Parameters: none
//
// Returns:   void
//
// Called by: main
// Calls:  update_array
void Organizer::update_array()
{
	int i=0, x=0;								// variable declaration
	string temp;								
	string old;
	string name1;
	string test1;
	string bnk = "blank";						// default string

	Student test;								// student type test 
												// *cant remember wat exactly this is for
	Student std;								// student type std

	ifstream infile("students.data");			// opens an input file

	while( !infile.eof() && x < 100 )			// while not equal to end of file
	{											// and while in the bounds of the array
		getline( infile, temp, '\n' );			// get command
		
		std.update_name(bnk);					// set to default values
		std.update_phone(bnk);
		std.update_email( bnk );	
		std.update_address1(bnk);
		std.update_address2(bnk);
		std.update_city(bnk);
		std.update_state(bnk);
		std.update_zip( bnk);
		std.update_other(bnk);
		
		while( temp != "@@" )						// while not = to @@
		{											// search through the data
			
			if( temp == "@Name:" )					// updates the student object w/ data
			{
				getline( infile, name1, '\n' );
				std.update_name( name1 );
			}
			else if( temp == "@Phone Number:")
			{
				getline( infile, name1, '\n' );
				std.update_phone( name1 );
			}
			else if( temp == "@E-mail:" )
			{
				getline( infile, name1, '\n' );
				std.update_email( name1 );
			}
			else if(temp == "@Address Line 1:")
			{
				getline( infile, name1, '\n' );
				std.update_address1( name1 );
			}
			else if(temp == "@Address Line 2:")
			{
				getline( infile, name1, '\n' );
				std.update_address2( name1 );
			}
			else if(temp == "@City:")
			{
				getline( infile, name1, '\n' );
				std.update_city( name1 );
			}
			else if(temp == "@State:")
			{
				getline( infile, name1, '\n' );
				std.update_state( name1 );
			}
			else if(temp == "@Zipcode:")
			{
				getline( infile, name1, '\n' );
				std.update_zip( name1 );
			}
			else if(temp == "@Other:")
			{
				getline( infile, name1, '\n' );
				std.update_other( name1 );
			}
			else
			{
				break;
			}
			getline( infile, temp, '\n' );				// get next command
		}
		getline( infile, temp, '\n' );					// gets white space
		
		array[i] = std;									// stores teh student object in the array
		i++;											// increment i
		x++;											// increments x
		count++;										// increments # objexts in the array
	}

	/*test = org.array[2];
	test1 = test.city;
	if( test1 == "blank" )
		cout << "Null\n";
	else
		cout << test1 << endl; */
}

//////////////////////////////////////////////////////////////// <add_student>
// <this function is passed a student object and then searches through the
// array for a free space.  When a free space is found the object is added
// to the array
// Parameters:
//			Student std- student object		
//
// Returns:   boolean - true/false
//
// Called by: command
// Calls:  update_array, access_array
bool Organizer::add_student( Student std )
{
	string str;									// variable declarations
	int m=0;
	Student tink;
	string bnk ="blank";
	if( count > 100 )
		return false;
	
	while( m < 100 )							// while less then 100
	{											// search through the array
		tink = array[m];						// gets object
		str = tink.access_email(tink);			// gets email address

		if( str == bnk )						// if the email address is set to default
		{
			array[m] = std;						// add the item to that possision
			add++;								// increments students added
			if( deleted == add )				// if students added = students deleted then no 
				count++;						// free spots so adds to the end of array increment 
			return true;						// # of student objects
		}
		m++;									// increment m
	}	
	return false;								// otherwise if not added return false
}

//////////////////////////////////////////////////////////////// <add_item>
// <this function add multimedia objects to the array1.  It attempts
// to add the objects to available free spaces if none are available 
// adds to the end the array
// Parameters:
//		Multimedia multi- multimedia object
//
// Returns:   boolean - returns true/false
//
// Called by: command
// Calls:  
bool Organizer::add_item( Multimedia multi )
{
	int x = -1;										// function declarations
	Student temp1;
	Multimedia tink;
	Multimedia temp;
	string str;
	string bnk = "blank";
	int i=0, m=0;
	string email1;
	string email2;
	string email3;
	email1 = multi.access_owner( multi );			// gets email1 from multi
	
	while( i < 100 )								// if there are not student objects
	{												// with the same email address	
		temp = array1[i];							// then the multimedia object can not be added
		temp1 = array[i];
		email2 = temp.access_owner( temp );
		email3 = temp1.access_email( temp1 );

		if( email3 == email1 )
			x = 0;
		i++;
	}
	if( x == -1 )									// if still = -1 return false
		return false;							
	if( count1 > 100 )								// if there is not room in the array left
		return false;								// return false
	
	//array1[count1+1] = multi;
	//return true;
	while( m < 100 )								// adds multimedia object to available 
	{												// slots in the array
		tink = array1[m];
		str = tink.access_owner(tink);

		if( str == bnk )
		{
			array1[m] = multi;
			add1++;
			if( deleted1 == add )
				count1++;
			return true;
		}
		m++;										// increment m
	}	
	return false;									// return false
}

//////////////////////////////////////////////////////////////// <update_array1>
// <this function accepts multimedia information and update and creates
// new multimedia objects and then adds them to array1
//
// Parameters: none
//		
// Returns:   void
//
// Called by: main
// Calls:  
void Organizer::update_array1()
{
	int i=0, zip1=0, z=0;								// variable declarations
	string temp;
	string name1;
	string test1;
	string bnk = "blank";

	Multimedia std;										// multimedia type std

	ifstream infile("items.data");						// opens output for output

	while( !infile.eof() && z < 100 )					// while not = end of file
	{													// and while w/in boundies of the array1
		getline( infile, temp, '\n' );
		
		std.update_item( bnk );							// set default values
		std.update_media(bnk);
		std.update_by( bnk );	
		std.update_owner( bnk );
		std.update_price( bnk );
		std.update_avail( bnk );
		
		while( temp != "@@" )							// while not = @@ update the multi object
		{
			if( temp == "@Item:" )
			{
				getline( infile, name1, '\n' );
				std.update_item( name1 );
			}
			else if( temp == "@Media Type:")
			{
				getline( infile, name1, '\n' );
				std.update_media( name1 );
			}
			else if( temp == "@by:" )
			{
				getline( infile, name1, '\n' );
				std.update_by(name1);
			}
			else if(temp == "@Owner:")
			{
				getline( infile, name1, '\n' );
				std.update_owner(name1);
			}
			else if(temp == "@Price:")
			{
				getline( infile, name1, '\n' );
				std.update_price( name1 );
			}
			else if(temp == "@Availability:")
			{
				getline( infile, name1, '\n' );
				std.update_avail( name1 );
			}
			else
				break;									// break from loop
			
			getline( infile, temp, '\n' );				// get next command
		}
		getline( infile, temp, '\n' );					// get white space
		array1[i] = std;								// store object in array
		count1++;										// increment # of object in array
		i++;											
		z++;
	}
	
}