//FlightDatabase.cpp -- assignment 3, summer 2001
//author: Rebecca Price, id: XXXXXXX, section: AA, TA: Man Chun Liu


#include "FlightDatabase.h"


const int DEFAULT_CAP = 5;


// default constructor
FDatabase::FDatabase(){
    capacity = DEFAULT_CAP;
    size = 0;
    flightArray = new Flight[capacity];
    assert (flightArray != NULL);
}


// copy constructor
FDatabase::FDatabase(const FDatabase& other){
    copy(other);
}



// overload operator to copy a flight into a new instance
FDatabase& FDatabase::operator =(const FDatabase& other){
    if(this != &other){
        cleanup();
        copy(other);
    }
    return *this;
}



// destructor calls cleanup
FDatabase::~FDatabase(){
    cleanup();
}



// deallocates dynamic memory
void FDatabase::cleanup(){
    delete [] flightArray;
    
}


// copies info from one instance of flight into another
void FDatabase::copy(const FDatabase& other){
    capacity = other.capacity;
    flightArray = new Flight[capacity];
    for(int i = 0; i < capacity; i++){
        flightArray[i] = other.flightArray[i];
    }
}



// updates/replaces old info any flights that have the same flight number
bool FDatabase::updateInfo(Flight& other){
    for(int i = 0; i < size; i++){
        // search through current flight info for match.
        // if there is a  then new info copied over and return true.
        if(flightArray[i].GetFlightNum() == other.GetFlightNum()){
            flightArray[i].copy(other);
            return true;
        }
    }
    return false;
}



// adds the info in other into the flightArray
void FDatabase::AddFlight(Flight& other, int count){
    EnsureCapacity(count + 1);
#ifdef DEBUGGING
    cout<<"addFlight befoer assign"<<flightArray[count].GetFlightNum();
#endif
    flightArray[count] = other;

// way to check it the capacity is being increased properly.
#ifdef DEBUGGING
    cout<<"The capacity is : "<<GetCapacity()<<endl;
#endif

}




// reads the file
bool FDatabase::OpenFlightFile(){
    string fileName;    // variable to store flight file name.
    bool endOfData = false; // set reading file condition.
    int i = 0;
    // variables to hold flight instances.
    string number, dLoc, aLoc, dTime, aTime, dDate, dummy;
    double amount;  // holds price of flight.
    Flight temp;    // temperary storage of file info until added into database.

    // ask user for file name.
    cout<<"Please enter the file name: ";
    cin>>fileName;
    cout<<endl<<endl;

    // open file, named Info.
    ifstream Info(fileName.c_str());
    if(!Info){
        // prints out error if file is not opened correctly.
        cout<<"Error in the file opening."<<endl;
        return false;
    }

    // gets info from file.
    getline(Info, number);

    while (!Info.eof() && (!endOfData)){
        // when number is an empty string endOfData gets set ot true and the loop exits.
        if(number == ""){
            endOfData = true;
        // when the number if not empty the information is read into a temp Flight.
        }else{
            getline(Info, dLoc);
            getline(Info, aLoc);
            getline(Info, dTime);
            getline(Info, aTime);
            getline(Info, dDate);
            Info>>amount;
            getline(Info, dummy);
            temp.SetFlightNum(number);
            temp.SetDepatureLoc(dLoc);
            temp.SetArrivalLoc(aLoc);
            temp.SetDepartTime(dTime);
            temp.SetArrivalTime(aTime);
            temp.SetDate(dDate);
            temp.SetPrice(amount);
            // if the flight number does not occur in the current database the 
            // flight is added and the size of the array increases, keeping tab on
            // the necessary capacity for the dynamic memory of flightArray.
            //
            if(!(updateInfo(temp))){
                AddFlight(temp, GetSize());
                SetSize(GetSize() + 1);
            }
            getline(Info, number);
        }
    }
    
    
//Debug to check if flight info has been entered correctly.
#ifdef DEBUGGING
    PrintFlightInfo();
    cout<<"File reading complete"<<endl<<endl<<endl;
#endif
    

    return true;

}




// ensures that there is enough capacity to hold all the flight info
void FDatabase::EnsureCapacity(int requireCapacity){
    if(capacity >= requireCapacity)
        return; // returns if capacity is large enough to hold info.

    // since capacity was not large enough it is doubled or set 
    // equal to the required size.
    int newCapacity = capacity *2;
    if(newCapacity <= requireCapacity){
        newCapacity = requireCapacity;
    }

    // set a new dynamic memory the size of the new capacity.
    Flight* newFlightArray = new Flight[newCapacity];

    // copy old flight info into new Flight Array
    for(int i = 0; i < size; i++){
        newFlightArray[i] = flightArray[i];
    }

    // delete the old array and reset new array to old variable name.
    delete [] flightArray;
    flightArray = newFlightArray;
    capacity = newCapacity;
}




// cancels/deletes the flight the user requests to be deleted from the database 
void FDatabase::CancelFlight(){
    PrintFlightInfo();
    string flightToBeCanceled;  // stores the flight number to be canceled.
    bool exit = false;

    do{

        cout<<"Please enter the flight number you would like to cancel: ";
        cin>>flightToBeCanceled; 
        if(flightToBeCanceled == "-1"){
            exit = true;
        }else{
            // look thru the flight DataBase and remove this flight number
            bool flightFound = false;
            for(int j = 0; j < size; j++){
                // see if flightArray[j].number matches
                if(flightArray[j].GetFlightNum() == flightToBeCanceled){
                    // have a match - this one is to be removed
                    flightArray[j].SetCanceledFlight(true);
                    flightFound = true;
                }
            }

            
            if(!flightFound){
                cout << "No flight found ";
            } else {
                
                // All the flights that matched were marked as canceled
                // Compact the database and leave some empty slots for new reservations
                CompactFlightDataBase(DEFAULT_CAP);
                
                //Debig check to make sure that the flight info has been removed.
                #ifdef DEBUGGING
                    PrintFlightInfo();
                    cout<<"The size of the database is: "<<GetSize();
                #endif
            }
        }
    }while(!exit);


    return;

}



// compact the flight database when a flight is deleted, leaves some empty slots
void FDatabase::CompactFlightDataBase(int spareCapacityCount){
    // go thru flightArray
    // copy any non canceled flights to a new array
    // assign the new array to flight array
    // increase the new array by the spareCapacityCount
    //

    // need to know how big newFlight should be
    // quick scan on flightArray
    // to see how many valid flights there are
    int a;
    int validCount = 0;
    for(a = 0; a< size; a++){
        if(!flightArray[a].FlightIsCanceled()){
            ++validCount;
        }
    }
    // validCount is how many valid flights we have
    

    // create newFlight big enough with spare
    // space as specified by spareCapacityCount
    SetCapacity (validCount + spareCapacityCount);

    Flight* newFlight = new Flight[capacity];

    int newCount = -1;

    // copy all valid entries from flightArray to newFlight
    for(a = 0; a < size; a++){
        if(!flightArray[a].FlightIsCanceled()){
            // valid uncanceled flight - copy it to new array
            newCount++;
            newFlight[newCount] = flightArray[a];
        }
    }


    // all valid ones copied accross
    // remove old db
    cleanup();

    // assign new one
    flightArray = newFlight;
    SetSize(validCount);
}



// sort the flight in ascending order according to price
void FDatabase::SortFlight(Flight* fArray, int fCount){
    // create a temp Flight to allow for swap.
    // basic sort that grabs the first element and then searches through for any past
    // elements that are less than the original. If less than then they are swapped and
    // the loop continues.
    //
    Flight temp;
    for(int i = 0; i < fCount; i++){
        for(int k = i + 1; k < fCount; k++){
            if(fArray[i].GetPrice() > fArray[k].GetPrice()){
                temp = fArray[i];
                fArray[i] = fArray[k];
                fArray[k] = temp;
            }
        }
    }
    
}





// print Info, by default prints contents of flightArray
void FDatabase::PrintFlightInfo(){
    PrintFlightInfo(flightArray, GetSize(), "Current Flight List");
}



// prints out the necessary information of a Flight array
void FDatabase::PrintFlightInfo(Flight* fArray, int fCount, string title){
    SortFlight(fArray, fCount);

    cout<<endl<<endl<<title<<endl<<endl;

    cout<<"Number  "<<"  Depart From    "<<"  Arrive At   "<<"Departure  "<<" Arrival  ";
    cout<<"  Date       "<<"Price"<<endl;
    cout<<"-------------------------------------------------------------------------------"<<endl;
    for(int i = 0; i < fCount; i ++){
        if(!fArray[i].FlightIsCanceled()){
            // flight not canceled
            // ensure not flight num 00000 (just unused slots)
            // dont want to show the user them
            if(fArray[i].GetFlightNum()!="00000"){      
                fArray[i].PrintInfo();
            }
        }
    }
    cout<<endl<<endl<<endl;
}



void FDatabase::PrintReservationInfo(Flight* fArray, int fCount, string title){
    SortFlight(fArray, fCount);
    cout<<endl<<endl<<title<<endl<<endl;
    for(int i = 0; i < fCount; i++){
        cout<<(i + 1)<<")";
        cout<<"   Flight Number: "<<fArray[i].GetFlightNum()<<endl;
        cout<<"     Total Price: $"<<fArray[i].GetPrice()<<endl<<endl<<endl;
    }
}





// allows the user to reserve a flight, look up all flights that match 
// their request and prints them out
void FDatabase::FlightReserve(){
    Flight temp;
    Flight* reservationMatches;
    string dLoc, aLoc, date;


    // init reservationMatches to empty to get started
    // Start off with 0 matches found for the reservation
    // Initialize reservation list (reservationMatches) to default capacity
    //
    int matchCount = -1;
    bool exit = false;


    // use current flightArray capacity as we know that there cannot be more matches than flights
    reservationMatches = new Flight[GetCapacity()];
    assert (reservationMatches!= NULL);


    do{
        PrintFlightInfo();
        // grab and store the user's requests
        cout<<"Please enter the desired departure location: ";
        cin>>dLoc;
        if(dLoc == "-1"){
            exit = true;
        }else{
            temp.SetDepatureLoc(dLoc);
            cout<<endl<<"Please enter the desired arrival location: ";
            cin>>aLoc;
            temp.SetArrivalLoc(aLoc);
            cout<<"Please enter the desired departure date: ";
            cin>>date;
            temp.SetDate(date);


            // temp comtains the target flight details
            // look thru flightArray and store any matches in 
            //  reservationMatches
            //
            bool flightsFound = false;
            for(int i = 0; i < size; i++){
                if(temp == flightArray[i]){
                    // have found a potential match for the user
                    // save flightArray[i] into next available slot
                    // in reservationMatches
                    //
                    matchCount++;
                    // ensure capacity in reservationMatches
                    // save the flight we found :)
                    reservationMatches[matchCount]  = flightArray[i];
                    flightsFound = true;
                }
                    
            }
            // if flightsFound is true, there is a match, then those matches are sent to be printed.
            if(flightsFound){
                PrintReservationInfo(reservationMatches, matchCount+1, "Reservation matches found!");
                int reservedNumber;
                cout<<"Please select the number you want: ";
                cin>>reservedNumber;
                cout<<"Here is all the relevant information for the flight you selected"<<endl;
                cout<<"Number  "<<"  Depart From    "<<"  Arrive At   "<<"Departure  "<<" Arrival  ";
                cout<<"  Date       "<<"Price"<<endl;
                cout<<"-------------------------------------------------------------------------------"<<endl;
                reservationMatches[reservedNumber - 1].PrintInfo();
                cout<<endl<<endl<<endl;

            // if there are no matches then print out command.
            }else{
                cout<<"No matches found! sorry ;)"<<endl<<endl;
            }
        }
    }while (!exit);
}



// sets the capacity
void FDatabase::SetCapacity(int current){
    capacity = current;
}



// returns capacity
int FDatabase::GetCapacity() const{
    return capacity;
}




// sets the size
void FDatabase::SetSize(int arraySize){
    size = arraySize;
}


// returns the size
int FDatabase::GetSize() const {
    return size;
}