//DataBase.cpp

#include "DataBase.h"
#include <cassert>
#include <iomanip>

DataBase::DataBase(){

	NumStudents = 0;
	NumItems = 0;

}


//////////////////////////////////////////////////////////////// Load
// Loads items and students
//
// Parameters:
//   <List each parameter and give a brief description of its purpose.>
//
// Pre:       <List the preconditions; i.e., the things that must be true
//             before the function is called.  Usually these involve whether
//             and how parameters must be initialized before the call, etc.>
//
// Post:      <List the postconditions; i.e., the things that are guaranteed
//             to be true when the function finishes, assuming that the
//             listed preconditions are satisfied.>
//
// Returns:   Describe what value the function returns, if any.
//
// Called by: <List the name(s) of the function(s) that call this one.>
// Calls:     <List the name(s) of the function(s) that this one calls.>
//


void	DataBase::Load(){

	ifstream IN1;
	ifstream IN2;
	IN1.open("students.data");
	IN2.open("items.data");


	//add assert
	assert(!IN1.fail());

	//add assert

	//int i, j;
	
	//i = j = 0;

	string Next;

	IgnoreBlank(IN1);
	getline(IN1, Next, '\n');
	//IN1.ignore(10,'\n');

	while(IN1){

	//cout << endl << "next " << Next;

		S[NumStudents].AddStudent(IN1, Next);

		

		//IgnoreBlank(IN1);
		IgnoreBlank(IN1);
		getline(IN1, Next, '\n');
		//i++;
		NumStudents++;
		//IN1.ignore(10,'\n');

	}

	IgnoreBlank(IN2);
	getline(IN2, Next, '\n');
	//IN1.ignore(10,'\n');

	while(IN2){

		I[NumItems].AddItem(IN2, Next, S, NumStudents);

		

		IgnoreBlank(IN2);
		getline(IN2, Next, '\n');

		//j++;
		NumItems++;
		//IN1.ignore(10,'\n');
	}

	IN1.close();
	IN2.close();

}

//////////////////////////////////////////////////////////////// <Function Name>
// <Brief description of what the function does.>
//
// Parameters:
//   <List each parameter and give a brief description of its purpose.>
//
// Pre:       <List the preconditions; i.e., the things that must be true
//             before the function is called.  Usually these involve whether
//             and how parameters must be initialized before the call, etc.>
//
// Post:      <List the postconditions; i.e., the things that are guaranteed
//             to be true when the function finishes, assuming that the
//             listed preconditions are satisfied.>
//
// Returns:   Describe what value the function returns, if any.
//
// Called by: <List the name(s) of the function(s) that call this one.>
// Calls:     <List the name(s) of the function(s) that this one calls.>
//


void	DataBase::AddStudent(ifstream& inFile, ofstream& outFile){

	string Next;

	bool Owner = false, Added = false;

	getline(inFile, Next, '\n');

	for(int i = 0; i<NumStudents; i++){
		if(S[i].ReturnDeleted() == true && !Added){
				Owner = S[i].AddStudent(inFile, Next);
				if(Owner){
					S[i].UnDelete();
				}
				Added = true;
		}
	}



	if(!Added){

		Owner = S[NumStudents].AddStudent(inFile, Next);
		if(Owner){
			NumStudents++;
		}
	}



	if(Owner){

		//NumStudents ++;
		outFile << "Success\n";

	}

	else{

		outFile << "Failure\n";

	}

}

//////////////////////////////////////////////////////////////// <Function Name>
// <Brief description of what the function does.>
//
// Parameters:
//   <List each parameter and give a brief description of its purpose.>
//
// Pre:       <List the preconditions; i.e., the things that must be true
//             before the function is called.  Usually these involve whether
//             and how parameters must be initialized before the call, etc.>
//
// Post:      <List the postconditions; i.e., the things that are guaranteed
//             to be true when the function finishes, assuming that the
//             listed preconditions are satisfied.>
//
// Returns:   Describe what value the function returns, if any.
//
// Called by: <List the name(s) of the function(s) that call this one.>
// Calls:     <List the name(s) of the function(s) that this one calls.>
//


void	DataBase::AddItem(ifstream& inFile, ofstream& outFile){

	bool Owned = false, Added = false;

	string Next;

	getline(inFile, Next, '\n');

	//check for empty spaces
	for(int i = 0; i<NumItems; i++){
		if(I[i].ReturnDeleted() == true && Added == false){
			Owned = I[i].AddItem(inFile, Next, S, NumStudents);
				if(Owned){
					I[i].UnDelete();
				}
			Added = true;
		}
	}

	if(!Added){

		Owned = I[NumItems].AddItem(inFile, Next, S, NumStudents);

		if(Owned){
			NumItems++;
		}

	}

	if(Owned){

		outFile << "Success\n";
	}

	else{


		outFile << "Failure\n";
	}
}

//////////////////////////////////////////////////////////////// <Function Name>
// <Brief description of what the function does.>
//
// Parameters:
//   <List each parameter and give a brief description of its purpose.>
//
// Pre:       <List the preconditions; i.e., the things that must be true
//             before the function is called.  Usually these involve whether
//             and how parameters must be initialized before the call, etc.>
//
// Post:      <List the postconditions; i.e., the things that are guaranteed
//             to be true when the function finishes, assuming that the
//             listed preconditions are satisfied.>
//
// Returns:   Describe what value the function returns, if any.
//
// Called by: <List the name(s) of the function(s) that call this one.>
// Calls:     <List the name(s) of the function(s) that this one calls.>
//


void	DataBase::DeleteStudent(ifstream& inFile, ofstream& outFile){

	string Delete;
	bool found1 = false;
	//bool found2 = false;

	inFile >> ws;
	getline(inFile, Delete, '\n');

	outFile << "delete " << Delete <<endl;

	//cout << NumStudents << endl;
	for(int i = 0; i<NumStudents; i++){
		if(S[i].ReturnEmail() == Delete && S[i].ReturnDeleted() == false){

			found1 = true;
			//S[i].DeleteStudent();
            //cout << " items " << NumItems;
			//for(int j = i; j< NumStudents; j++){
				//cout << j << endl;
				//S[j] = S[j+1];
				S[i].DeleteStudent();
			//}
		}	
	}

	//if found, delete items
	if(found1){

		for(int p = 0; p<NumItems; p++){

			if(I[p].ReturnOwner() == Delete){
			
				I[p].Delete();
			}
		
		//NumStudents--;
		}

		outFile << "Success\n";
	}
	else{

		outFile << "Failure\n";
	}

	/*if(found2){
		NumItems--;
		//cout << NumItems;
	}*/

}


//////////////////////////////////////////////////////////////// <Function Name>
// <Brief description of what the function does.>
//
// Parameters:
//   <List each parameter and give a brief description of its purpose.>
//
// Pre:       <List the preconditions; i.e., the things that must be true
//             before the function is called.  Usually these involve whether
//             and how parameters must be initialized before the call, etc.>
//
// Post:      <List the postconditions; i.e., the things that are guaranteed
//             to be true when the function finishes, assuming that the
//             listed preconditions are satisfied.>
//
// Returns:   Describe what value the function returns, if any.
//
// Called by: <List the name(s) of the function(s) that call this one.>
// Calls:     <List the name(s) of the function(s) that this one calls.>
//


void	DataBase::PrintStudents(ofstream& outFile){

	//cout << "\n*** PRINTING STUDENTS ***\n";

	for(int i = 0; i < NumStudents; i++){
		
		if(S[i].ReturnDeleted() == false){

			S[i].PrintInfo(outFile);

		}
	}

}


//////////////////////////////////////////////////////////////// <Function Name>
// <Brief description of what the function does.>
//
// Parameters:
//   <List each parameter and give a brief description of its purpose.>
//
// Pre:       <List the preconditions; i.e., the things that must be true
//             before the function is called.  Usually these involve whether
//             and how parameters must be initialized before the call, etc.>
//
// Post:      <List the postconditions; i.e., the things that are guaranteed
//             to be true when the function finishes, assuming that the
//             listed preconditions are satisfied.>
//
// Returns:   Describe what value the function returns, if any.
//
// Called by: <List the name(s) of the function(s) that call this one.>
// Calls:     <List the name(s) of the function(s) that this one calls.>
//


void	DataBase::PrintItems(ofstream& outFile){

	//cout <<  NumItems;

	for(int i = 0; i < NumItems; i++){
		if(!I[i].ReturnDeleted() ){
		I[i].PrintInfo(outFile);
		}
	}
}


//////////////////////////////////////////////////////////////// <Function Name>
// <Brief description of what the function does.>
//
// Parameters:
//   <List each parameter and give a brief description of its purpose.>
//
// Pre:       <List the preconditions; i.e., the things that must be true
//             before the function is called.  Usually these involve whether
//             and how parameters must be initialized before the call, etc.>
//
// Post:      <List the postconditions; i.e., the things that are guaranteed
//             to be true when the function finishes, assuming that the
//             listed preconditions are satisfied.>
//
// Returns:   Describe what value the function returns, if any.
//
// Called by: <List the name(s) of the function(s) that call this one.>
// Calls:     <List the name(s) of the function(s) that this one calls.>
//


void	DataBase::PrintStudent(ifstream& inFile, ofstream& outFile, string ToPrint){

	outFile << "print " << ToPrint;

	bool found = false;

	for(int i = 0; i < NumStudents; i++){
		if(S[i].ReturnEmail() == ToPrint && S[i].ReturnDeleted() == false){
			S[i].PrintInfo(outFile);
			found = true;
		}
	}

	outFile << endl;

	if(!found){
		outFile << ToPrint << " not found.\n";
	}
		//print student info
	
	else{
		for(int j = 0; j < NumItems; j++){

			if(I[j].ReturnOwner() == ToPrint && I[j].ReturnDeleted() == false){
				//cout << I[j].ReturnOwner();
				
				if(I[j].ReturnName() != "blank"){

				outFile << "Item:\n";
				outFile << " " << I[j].ReturnName() <<endl;
				}

				if(I[j].ReturnType() != "blank"){
					outFile << "Media Type:\n";
					outFile << " " << I[j].ReturnType() << endl;
				}

				if(I[j].ReturnAuthor() != "blank"){
					outFile << "by:\n";
					outFile << " " << I[j].ReturnAuthor() << endl;
				}

				/*if(Owner != "blank"){
					outFile << "Owner:\n";
					outFile << '\t' << Owner << endl;
				}*/

				if(I[j].ReturnPrice() > 0.0){
					outFile << "Price:\n";
					outFile << " " << "$" << fixed << setprecision(2) << I[j].ReturnPrice() << endl;
				}

				if(I[j].ReturnAvailability() != "blank"){
					outFile << "Availability:\n";
					outFile << " " << I[j].ReturnAvailability() << endl;
				}
			
			outFile << endl;

			}
		}
	}
}


void DataBase::IgnoreBlank(ifstream& IN){

	if(IN.peek() == '\n'){
		
		IN.ignore(100, '\n');

	}
}