// Programmer:		Postell Carter
// Last Modified:	June 6, 2003
// Compiler:		Visual C++.NET

// This programs creates a multimedia organizer that hold a list of students and their
// multimedia items.  The programs utilizes three classes, one for the student object,
// one for the item object and one for the organizer object.  The organizer will be able
// to handle a few commands that manipulate data in the organizer, such as print student,
// add student and delete student.  The program must also incorporate at least 3 testing
// switches and 3 assert statements.
//
// 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 of unmodified.
//
// - If any C++ language code or documentation used in my program
//   was obtained from another source, such as a text book 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.
//
// Postell Carter
//
#include <iostream>     // For input from and output to the screen
#include <cstdlib>		// For testing switches
#include <fstream>		// For input and output file streams
#include <string>		// For STRING data
#include <sstream>		// For string stream
#include <cassert>		// For assert command

using namespace std;

const int MAXSIZE = 100;

// Holds Student Information
class Student {
	friend class Organizer;

public:
	Student();
	~Student();

private:
	string stName;			// For student name
	string stNumber;		// For student phone number
	string stEmail;			// For student email
	string stAddrLine1;		// Next 5 variables for student address
	string stAddrLine2;
	string stCity;
	string stState;
	string stZipcode;
	string stOther;			// For extra data about student
	bool isEmpty;			// To show whether the cell is empty or not
};

// Default Constructor - Initializes each Student object
Student::Student() {

	stName = "Empty";
	stNumber = "Empty";
	stEmail = "Empty";
	stAddrLine1 = "Empty";
	stAddrLine2 = "Empty";
	stCity = "Empty";
	stState = "Empty";
	stZipcode = "Empty";
	stOther = "Empty";	
	isEmpty = true;
}

// class Destructor
Student::~Student() {}

// Holds Item information
class Item {
	friend class Organizer;
	
public:
	Item();
	~Item();

private:
	string itemName;		// For name of item
	string itemType;		// For type of item
	string itemArtist;		// For name of Artist
	string itemEmail;		// For owner's email
	string itemPrice;		// For price of item
	string itemAvail;		// For item's availability status
	bool isEmpty;			// To show whether cell is empty or filled
};

// Default constuctor - Initializes Item object
Item::Item() {

	itemName = "Empty";
	itemType = "Empty";
	itemArtist = "Empty";
	itemEmail = "Empty";
	itemPrice = "Empty";
	itemAvail = "Empty";
	isEmpty = true;
}

// class Destructor
Item::~Item() {}

// Holds arrays of both Student and Items objects and the functions that access or modify them
class Organizer {

public:
	Organizer();
	~Organizer();
	void printStudents(ofstream&) const;
	void printItems(ofstream&) const;
	void printStudItems(ofstream&, string) const;
	void addStudent(ifstream&, ofstream&);
	void addItem(ifstream&, ofstream&);
	void deleteStudItems(ofstream&, string);
	
private:
	Student studList[MAXSIZE];
	Item itemList[MAXSIZE];
};

// class Constructor - Reads student information from students.data and item information
// from items.data and inserts the information into the appropriate array
Organizer::Organizer() {

	ifstream Infile("students.data");

	string fieldToAdd;			// To determine which field the data is for
	string name;				// Next 9 variables are temporary variables to
    string number;				// hold student data until it is input in a student
	string studEmail;			// object
	string addr1;
	string addr2;
	string city;
	string state;
	string zip;
	string other;
	bool stillData = true;			// Variable ends loop when the end of input file is found


	getline(Infile, fieldToAdd);

	while(stillData == true) {
		while (fieldToAdd != "@@")
		{
			if (fieldToAdd == "@Name:")
				getline(Infile, name);
			else if (fieldToAdd == "@Phone Number:")
				getline(Infile, number);
			else if (fieldToAdd == "@E-mail:")
				getline(Infile, studEmail);
			else if (fieldToAdd == "@Address Line 1:")
				getline(Infile, addr1);
			else if (fieldToAdd == "@Address Line 2:")
				getline(Infile, addr2);
			else if (fieldToAdd == "@City:")
				getline(Infile, city);
			else if (fieldToAdd == "@State:")
				getline(Infile, state);
			else if (fieldToAdd == "@Zipcode:")
				getline(Infile, zip);
			else if (fieldToAdd == "@Other:")
				getline(Infile, other);

			getline(Infile, fieldToAdd);
		}

		int i = 0;						// counter variable
		bool studAdded = false;			// Holds whether the information was input into the array

		if (studEmail != "") {
			while( i<MAXSIZE && studAdded == false) {
				if (studList[i].isEmpty == true) {
					studList[i].stName = name;
					name = "";
					studList[i].stNumber = number;
					number = "";
					studList[i].stEmail = studEmail;
					studEmail = "";
					studList[i].stAddrLine1 = addr1;
					addr1 = "";
					studList[i].stAddrLine2 = addr2;
					addr2 = "";
					studList[i].stCity = city;
					city = "";
					studList[i].stState = state;
					state = "";
					studList[i].stZipcode = zip;
					zip = "";
					studList[i].stOther = other;
					other = "";
					studList[i].isEmpty = false;
					studAdded = true;
				}
				else
					i++;
			}
		Infile.ignore(INT_MAX, '\n');
		getline(Infile, fieldToAdd);
		}
		
		if (Infile.fail()) 
			stillData = false;
	}

	Infile.close();

	
	ifstream Infile2("items.data");

	string item;		// First 6 variables are temp variables
	string type;
	string artist;
	string email;
	string price;
	string avail;
	stillData = true;	// Hold whether the end of input file is found

	getline(Infile2, fieldToAdd);

	while (stillData == true) {
		while (fieldToAdd != "@@")
		{
			if (fieldToAdd == "@Item:")
				getline(Infile2, item);
			else if (fieldToAdd == "@Media Type:")
				getline(Infile2, type);
			else if (fieldToAdd == "@by:")
				getline(Infile2, artist);
			else if (fieldToAdd == "@Owner:")
				getline(Infile2, email);
			else if (fieldToAdd == "@Price:")
				getline(Infile2, price);
			else if (fieldToAdd == "@Availability:")
				getline(Infile2, avail);

			getline(Infile2, fieldToAdd);
		}


		int i = 0;						// counter variable
		int k = 0;						// counter variable
		bool itemAdded = false;			// Holds whether the data has been input into array
		bool acctFound = false;			// Holds whether the account is found in Student array

		if (email != "") {
			while( k<MAXSIZE && acctFound == false) {
				if (email == studList[k].stEmail)
					acctFound = true;
				else
					k++;
			}
		}

		if (acctFound == true) {
			while( i<MAXSIZE && itemAdded == false) {
				if (itemList[i].isEmpty == true) {
					itemList[i].itemName = item;
					item = "";
					itemList[i].itemType = type;
					type = "";
					itemList[i].itemArtist = artist;
					artist = "";
					itemList[i].itemEmail = email;
					email = "";
					itemList[i].itemPrice = price;
					price = "";
					itemList[i].itemAvail = avail;
					avail = "";
					itemList[i].isEmpty = false;
					itemAdded = true;
					}
				else
					i++;
			}
			Infile2.ignore(INT_MAX, '\n');
			getline(Infile2, fieldToAdd);
		}
		if (Infile2.fail()) 
		stillData = false;
		}
	Infile2.close();
}

// class Destructor
Organizer::~Organizer() {}

//////////////////////////////////////////////////////////////////////////////////////////////////
// Prints all Student Objects in Student array that have been filled with data
//
// Parameters:
//				Outfile - output stream
//
// Returns:
//				nothing
//
// Pre:			output file has been opened
//
// Post:		Information printed to output file
//
// Called by:   getCommand()
//
void Organizer::printStudents(ofstream& Outfile) const {

	Outfile << "print students\n";

	for (int i = 0; i<MAXSIZE; i++) {
		if (studList[i].isEmpty == false) {
			if (studList[i].stName != "") {
				Outfile << "Name:" << endl;
				Outfile << " " << studList[i].stName << endl;
			}
			if (studList[i].stNumber != "") {
				Outfile << "Phone Number:" << endl;
				Outfile << " " << studList[i].stNumber << endl;
			}
			if (studList[i].stEmail != "") {
				Outfile << "Email:" << endl;
				Outfile << " " << studList[i].stEmail << endl;
			}
			if (studList[i].stAddrLine1 != "" ||
				studList[i].stAddrLine2 != "" ||
				studList[i].stCity != "" ||
				studList[i].stState != "" ||
				studList[i].stZipcode != "") {
				Outfile << "Address:" << endl;
			}
			if (studList[i].stAddrLine1 != "") {
				Outfile << " " << studList[i].stAddrLine1 << endl;
			}
			if (studList[i].stAddrLine2 != "") {
				Outfile << " " << studList[i].stAddrLine2 << endl;
			}
			if (studList[i].stCity != "") {
				Outfile << " " << studList[i].stCity;
			}
			if (studList[i].stCity != "" &&
				(studList[i].stState != "" ||
				studList[i].stZipcode != "")) {
				Outfile << ",";
			}
			if (studList[i].stState != "") {
				Outfile << " " << studList[i].stState;
			}
			if (studList[i].stZipcode != "") {
				Outfile << " " << studList[i].stZipcode;
			}
			if (studList[i].stCity != "" ||
				studList[i].stState != "" ||
				studList[i].stZipcode != "") {
			Outfile << endl;
			}
			if (studList[i].stOther != "") {
				Outfile << "Other:" << endl;
				Outfile << " " << studList[i].stOther << endl;
			}
			Outfile << endl;
		}
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////////
// Prints all Item objects in Items array that have been filled with data
//
// Parameters:
//				Outfile - output stream
//
// Returns:
//				nothing
//
// Pre:			output file has been opened
//
// Post:		Information printed to output file
//
// Called by:   getCommand()
//
void Organizer::printItems(ofstream& Outfile) const {

	Outfile << "print items\n";

	for (int i = 0; i<MAXSIZE; i++) {
		if (itemList[i].isEmpty == false) {
			if (itemList[i].itemName != "") {
				Outfile << "Item:" << endl;
				Outfile << " " << itemList[i].itemName << endl;
			}
			if (itemList[i].itemType != "") {
				Outfile << "Media Type:" << endl;
				Outfile << " " << itemList[i].itemType << endl;
			}
			if (itemList[i].itemArtist != "") {
				Outfile << "by:" << endl;
				Outfile << " " << itemList[i].itemArtist << endl;
			}
			if (itemList[i].itemEmail != "") {
				Outfile << "Owner:" << endl;
				Outfile << " " << itemList[i].itemEmail << endl;
			}
			if (itemList[i].itemPrice != "") {
				Outfile << "Price:" << endl;
				Outfile << " " << itemList[i].itemPrice << endl;
			}
			if (itemList[i].itemAvail != "") {
				Outfile << "Availability:" << endl;
				Outfile << " " << itemList[i].itemAvail << endl;
			}
			Outfile << endl;
		}
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////////
// Prints the Items that are associated with a particular Student
//
// Parameters:
//				Outfile - output stream
//				acctToPrint - email of Student whose Items are to be printed
//
// Returns:
//				nothing
//
// Pre:			output file has been opened
//				acctToPrint has been determined
//
// Post:		Information printed to output file
//
// Called by:   getCommand()
//
void Organizer::printStudItems(ofstream& Outfile, string acctToPrint) const {

	Outfile << "print " << acctToPrint << endl;

	int k = 0;						// counter variable
	int i = 0;						// counter variable
	bool acctFound = false;			// Holds whether Student account was found

	while( k<MAXSIZE && acctFound == false) {
		if (acctToPrint == studList[k].stEmail) {
			assert( (i>=0) && (i<MAXSIZE) );
			if (studList[k].stName != "") {
				Outfile << "Name:" << endl;
				Outfile << " " << studList[k].stName << endl;
			}
			if (studList[k].stNumber != "") {
				Outfile << "Phone Number:" << endl;
				Outfile << " " << studList[k].stNumber << endl;
			}
			if (studList[k].stEmail != "") {
				Outfile << "Email:" << endl;
				Outfile << " " << studList[k].stEmail << endl;
			}
			if (studList[k].stAddrLine1 != "" ||
				studList[k].stAddrLine2 != "" ||
				studList[k].stCity != "" ||
				studList[k].stState != "" ||
				studList[k].stZipcode != "") {
				Outfile << "Address:" << endl;
			}
			if (studList[k].stAddrLine1 != "") { 
				Outfile << " " << studList[k].stAddrLine1 << endl;
			}
			if (studList[k].stAddrLine2 != "") {
				Outfile << " " << studList[k].stAddrLine2 << endl;
			}
			if (studList[k].stCity != "") {
				Outfile << " " << studList[k].stCity;
			}
			if (studList[k].stState != "") {
				Outfile << " " << studList[k].stState;
			}
			if (studList[k].stZipcode != "") {
				Outfile << " " << studList[k].stZipcode;
			}
			if (studList[i].stCity != "" ||
				studList[i].stState != "" ||
				studList[i].stZipcode != "") {
			Outfile << endl;
			}
			if (studList[k].stOther != "") {
				Outfile << "Other:" << endl;
				Outfile << " " << studList[k].stOther << endl;
			}
			Outfile << endl;
			acctFound = true;
		}
		else
			k++;
	}

	if (acctFound == false)
		Outfile << acctToPrint << " not found.\n";
	else {
		for (int i = 0; i<MAXSIZE; i++) {
			if (acctToPrint == itemList[i].itemEmail) {
				assert( (i>=0) && (i<MAXSIZE) );
				if (itemList[i].itemName != "") {
					Outfile << "Item:" << endl;
					Outfile << " " << itemList[i].itemName << endl;
				}
				if (itemList[i].itemType != "") {
					Outfile << "Media Type:" << endl;
					Outfile << " " << itemList[i].itemType << endl;
				}
				if (itemList[i].itemArtist != "") {
					Outfile << "by:" << endl;
					Outfile << " " << itemList[i].itemArtist << endl;
				}
				if (itemList[i].itemPrice != "") {
					Outfile << "Price:" << endl;
					Outfile << " " << itemList[i].itemPrice << endl;
				}
				if (itemList[i].itemAvail != "") {
					Outfile << "Availability:" << endl;
					Outfile << " " << itemList[i].itemAvail << endl;
				}
				Outfile << endl;
			}
		}
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////////
// Reads Student data from input file and, if valid, input it into Student array
//
// Parameters:
//				Infile - input stream
//				Outfile - output stream
//
// Returns:
//				nothing
//
// Pre:			output file has been opened
//				input file has been opened
//
// Post:		If valid Student object has been read, information is added to Student array
//
// Called by:   getCommand()
//
void Organizer::addStudent(ifstream& Infile, ofstream& Outfile) {

	Outfile << "add student\n";
	
	string fieldToAdd;				// To determine which field the data is for
	string name;					// The last variables are temp variables to hold data from input file
	string number;
	string email;
	string addr1;
	string addr2;
	string city;
	string state;
	string zip;
	string other;

	getline(Infile, fieldToAdd);

	while (fieldToAdd != "@@")
	{
		if (fieldToAdd == "@Name:")
			getline(Infile, name);
		else if (fieldToAdd == "@Phone Number:")
			getline(Infile, number);
		else if (fieldToAdd == "@E-mail:")
			getline(Infile, email);
		else if (fieldToAdd == "@Address Line 1:")
			getline(Infile, addr1);
		else if (fieldToAdd == "@Address Line 2:")
			getline(Infile, addr2);
		else if (fieldToAdd == "@City:")
			getline(Infile, city);
		else if (fieldToAdd == "@State:")
			getline(Infile, state);
		else if (fieldToAdd == "@Zipcode:")
			getline(Infile, zip);
		else if (fieldToAdd == "@Other:")
			getline(Infile, other);

		getline(Infile, fieldToAdd);
	}


	int i = 0;					// counter variable
	bool studAdded = false;		// holds whether Student was added to array

	if (email != "") {
		while( i<MAXSIZE && studAdded == false) {
			assert( (i>=0) && (i<MAXSIZE) );
			if (studList[i].isEmpty == true) {
				studList[i].stName = name;
				studList[i].stNumber = number;
				studList[i].stEmail = email;
				studList[i].stAddrLine1 = addr1;
				studList[i].stAddrLine2 = addr2;
				studList[i].stCity = city;
				studList[i].stState = state;
				studList[i].stZipcode = zip;
				studList[i].stOther = other;
				studList[i].isEmpty = false;
				studAdded = true;
				}
			else
				i++;
			}
	}

	if (studAdded == false)
		Outfile << "Failure\n";
	else
		Outfile << "Success\n";
}

//////////////////////////////////////////////////////////////////////////////////////////////////
// Reads Item data from input file and, if valid, input it into Item array
//
// Parameters:
//				Infile - input stream
//				Outfile - output stream
//
// Returns:
//				nothing
//
// Pre:			output file has been opened
//				input file has been opened
//
// Post:		If valid Item object has been read, information is added to Item array
//
// Called by:   getCommand()
//
void Organizer::addItem(ifstream& Infile, ofstream& Outfile) {

	Outfile << "add item\n";
	
	string fieldToAdd;			// To determine which field the data is for
	string item;				// The last variables are temp variables to hold Item data read from file
	string type;
	string artist;
	string email;
	string price;
	string avail;

	getline(Infile, fieldToAdd);

	while (fieldToAdd != "@@")
	{
		if (fieldToAdd == "@Item:")
			getline(Infile, item);
		else if (fieldToAdd == "@Media Type:")
			getline(Infile, type);
		else if (fieldToAdd == "@by:")
			getline(Infile, artist);
		else if (fieldToAdd == "@Owner:")
			getline(Infile, email);
		else if (fieldToAdd == "@Price:")
			getline(Infile, price);
		else if (fieldToAdd == "@Availability:")
			getline(Infile, avail);

		getline(Infile, fieldToAdd);
	}

	int i = 0;					// counter variables
	int k = 0;
	bool itemAdded = false;		// holds whether Item was added to array
	bool acctFound = false;		// holds whether Student account was found

	if (email != "") {
		while( k<MAXSIZE && acctFound == false) {
			if (email == studList[k].stEmail)
				acctFound = true;
			else
				k++;
		}
	}

	if (acctFound == true) {
		while( i<MAXSIZE && itemAdded == false) {
			assert( (i>=0) && (i<MAXSIZE) );
			if (itemList[i].isEmpty == true) {
				itemList[i].itemName = item;
				itemList[i].itemType = type;
				itemList[i].itemArtist = artist;
				itemList[i].itemEmail = email;
				itemList[i].itemPrice = price;
				itemList[i].itemAvail = avail;
				itemList[i].isEmpty = false;
				itemAdded = true;
				}
			else
				i++;
		}
	}

	if (itemAdded == false)
		Outfile << "Failure\n";
	else
		Outfile << "Success\n";

}

//////////////////////////////////////////////////////////////////////////////////////////////////
// Deletes information for particular account from Student array and Item array
//
// Parameters:
//				acctToDelete - account whose information to delete
//				Outfile - output stream
//
// Returns:
//				nothing
//
// Pre:			output file has been opened
//				account to delete has been determined
//
// Post:		If found, the account data has been erased from Student and Item arrays
//
// Called by:   getCommand()
//
void Organizer::deleteStudItems(ofstream& Outfile, string acctToDelete) {

	Outfile << "delete " << acctToDelete << endl;

	int i = 0;					// counter variables
	int k = 0;
	bool acctFound = false;		// holds whether Student account was found

	while( k<MAXSIZE && acctFound == false) {
		if (acctToDelete == studList[k].stEmail)
			acctFound = true;
		else
			k++;
	}

	if (acctFound == true) {
		Outfile << "Success\n";
		for ( i=0; i<MAXSIZE; i++) {
			assert( (i>=0) && (i<MAXSIZE) );
			if (studList[i].stEmail == acctToDelete) {
				studList[i].stName = "Empty";
				studList[i].stNumber = "Empty";
				studList[i].stEmail = "Empty";
				studList[i].stAddrLine1 = "Empty";
				studList[i].stAddrLine2 = "Empty";
				studList[i].stCity = "Empty";
				studList[i].stState = "Empty";
				studList[i].stZipcode = "Empty";
				studList[i].stOther = "Empty";
				studList[i].isEmpty = true;
			}
			if (itemList[i].itemEmail == acctToDelete) {
				itemList[i].itemName = "Empty";
				itemList[i].itemType = "Empty";
				itemList[i].itemArtist = "Empty";
				itemList[i].itemEmail = "Empty";
				itemList[i].itemPrice = "Empty";
				itemList[i].itemAvail = "Empty";
				itemList[i].isEmpty = true;
			}
		}
	}
	else
		Outfile << "Failure\n";
}

void getCommand();

int main(int argc, char* argv[]) {

	char screenPause;		// For testing switch

	if (argc>1 && atoi(argv[1])==1) {
		cout << "Prior to getting command." << endl;
		cin >> screenPause;
	}

	getCommand();

	if (argc>1 && atoi(argv[1])==2) {
		cout << "After commands are finished." << endl;
		cin >> screenPause;
	}

	if (argc>1 && atoi(argv[1])==3) {
		cin >> screenPause;
	}

	return 0;
}

//////////////////////////////////////////////////////////////////////////////////////////////////
// Reads command from input file and calls the appropriate function to handle the request
//
// Parameters:
//				argc, A - both variables are for testing switches
//
// Returns:
//				nothing
//
// Pre:			nothing
//
// Post:		All commands have been read and all functions completed
//
// Called by:   main()
//
void getCommand() {

	Organizer multOrganizer;		// Organizer that holds Student and Item arrays

	string commandLine;				// To hold command from input file
	string command1;				// Variables hold to hold command after it is seperated into 2 parts
	string command2;

	ifstream Infile("commands.data");

	ofstream Outfile("output.data");

	getline(Infile, commandLine);
	istringstream dbCommand( commandLine );
	dbCommand >> command1 >> command2;


	while (command1 != "quit") {
		if (command1 == "print") {
			if (command2 == "students") {
				multOrganizer.printStudents(Outfile);
				Infile.ignore(INT_MAX, '\n');
			}
			else if (command2 == "items") {
				multOrganizer.printItems(Outfile);
				Infile.ignore(INT_MAX, '\n');
			}
			else {
				multOrganizer.printStudItems(Outfile, command2);
				Infile.ignore(INT_MAX, '\n');
			}
		}
		else if (command1 == "add") {
			if (command2 == "student"){
				multOrganizer.addStudent(Infile, Outfile);
				Infile.ignore(INT_MAX, '\n');
			}
			else if (command2 == "item") {
				multOrganizer.addItem(Infile, Outfile);
				Infile.ignore(INT_MAX, '\n');
			}
		}
		else {
			multOrganizer.deleteStudItems(Outfile, command2);
			Infile.ignore(INT_MAX, '\n');
		}
		getline(Infile, commandLine);
		istringstream dbCommand( commandLine );
		dbCommand >> command1 >> command2;
	}

	Outfile.close();
}