#include "stdstuff.h"
#include "CustomerDB.h"

// private method to delete database; used by destructor and assignment
void CustomerDB::deleteDB() {
   if (numCusts>0)
      delete [] ci; // delete the dynamically allocated array
}
   
   
// private method to copy database; used by copy constructor and assignment
void CustomerDB::copyDB(const CustomerDB &otherCustDB) {
     
   numCusts = otherCustDB.numCusts; // set number of customers
   
   if(numCusts==0)
      ci = NULL;
   else { // if at least one customer, create and copy over the array
      ci = new Customer[numCusts];
      for (int i=0;i<numCusts;i++)
         ci[i] = otherCustDB.ci[i];
   }

   walkInProgress = false; // database changed
}

// the constructor creates an empty database
CustomerDB::CustomerDB() {
   numCusts=0; // no customers yet 
   ci = NULL; // no customers to pointer is NULL
   walkInProgress=false; // no walk in progress
}

// copy constructor
CustomerDB::CustomerDB(const CustomerDB &otherCustDB) {
   copyDB(otherCustDB); // copy the database
}
   
// destructor
CustomerDB::~CustomerDB() {
   cout << "destructor invoked\n";
   pause(); // so we can see this message at the end of the program
   
   deleteDB(); // deletes the dynamically allocated array
}
   
// assignment
CustomerDB& CustomerDB::operator=(const CustomerDB &otherCustDB) {
 
   deleteDB(); // deletes the old dynamically allocated array
   
   copyDB(otherCustDB); // copy the database
                        
   return *this;
}
   
// returns the number of customers in the database
int CustomerDB::getNumCusts() const {
   return numCusts;
}

// add a new customer to the database; returns true if successful, false otherwise
// (database full or customer already exists)
bool CustomerDB::add(const Customer &newCust) {
     
   Customer *temp;
   
   for(int i=0;i<numCusts;i++) {  
      // **must** use == method in Customer class     
      if(ci[i]==newCust) return false; // Customer already in database
   }
   
   // create new array and copy over the existing customers 
   temp = new Customer[numCusts+1]; // will always be at least 1
   for (int i=0;i<numCusts;i++)
      temp[i] = ci[i];
      
   delete [] ci;
   ci = temp;
   
   // insert new customer at end
   ci[numCusts] = newCust;
   
   numCusts++; // we've added a Customer
   walkInProgress = false; // we've changed the database
   return true; // success
}

// remove a customer from the database; returns true if successful, false otherwise (customer
// does not exist)
bool CustomerDB::remove(int id) {

   Customer *temp;
   
   for(int i=0;i<numCusts;i++) {
      if(ci[i].getID()==id) { // found it; **must** use getID
         numCusts--;
         ci[i] = ci[numCusts]; // decrement number of customers and move last one into ith pos'n
         
         // change array size
         if (numCusts==0) { // no remaining customers, so ci is now NULL
            delete [] ci;
            ci = NULL;
         } else { // create new smaller array and copy over the remaining customers
            temp = new Customer[numCusts];
            for (int j=0;j<numCusts;j++)
               temp[j] = ci[j];
      
            delete [] ci;
            ci = temp;
         }
         
         walkInProgress = false; // we've changed the database
         return true; // Customer removed
      }
   }
   
   return false; // Customer does not exist in database
}

// prints the full customer database (or a note if the database is empty); 
// Customers are printed one per line, with 2 decimals for the total.
void CustomerDB::print() const {
   
   if(numCusts==0) { // empty database
      cout << "Customer database is empty.\n";
      return;
   }
   
   // otherwise print each Customer (one per line), **must** use Customer's print
   for(int i=0;i<numCusts;i++) {
      ci[i].print();
   }
}

// change the customer number of an existing customer; returns true if successful, 
// false otherwise (customer does not exist, or new customer number in use)
bool CustomerDB::changeID(int id, int nid) {
      
   for(int i=0;i<numCusts;i++) { // check that new id not being used
      if(ci[i].getID()==nid) return false; // new id already in use (must use getID)
   }
     
   for(int i=0;i<numCusts;i++) {
      if(ci[i].getID()==id) { // found the one we want to change
         ci[i].setID(nid); // change the id, **must** use "setID" method
         walkInProgress = false; // we've changed the database
         return true; // Customer information updated
      }
   }
   
   return false; // Customer does not exist in database
}

// change the customer total of an existing customer; returns true if successful, 
// false otherwise (customer does not exist)
bool CustomerDB::changeTotal(int id, double ntotal) {
     
   for(int i=0;i<numCusts;i++) {
      if(ci[i].getID()==id) { // found the one we want to change so update total, use getID
         ci[i].setTotal(ntotal); // **must** use setTotal method
         walkInProgress = false; // we've changed the database
         return true; // Customer information updated
      }
   }
   
   return false; // Customer does not exist in database
}

// move the purchase date by the number of days given; returns true if successful, 
// false otherwise (customer does not exist)
bool CustomerDB::moveDate(int id, int days) {
   Date temp;
     
   for(int i=0;i<numCusts;i++) {
      if(ci[i].getID()==id) { // found the one we want to change so update total, use getID
         temp = ci[i].getDate(); // **must** use getDate and setDate methods
         temp.move(days); // adjust old date
         ci[i].setDate(temp);  // and set the date to the newly calculated date
         walkInProgress = false; // we've changed the database
         return true; // Customer information updated
      }
   }
   
   return false; // Customer does not exist in database
}

// append the given String2002 to the customer name; returns true if successful, 
// false otherwise (customer does not exist)
bool CustomerDB::appendName(int id, const String2002 &add) {

   for(int i=0;i<numCusts;i++) {
      if(ci[i].getID()==id) { // found the one we want to change so update total, use getID
         ci[i].setName(ci[i].getName()+add); // **must** use getName and setName methods
         walkInProgress = false; // we've changed the database
         return true; // Customer information updated
      }
   }
   
   return false; // Customer does not exist in database
}

// returns the lowest customer ID of all customers 
// (returns -1 if there are no customers in the database)
int CustomerDB::getLowestID() const {
   int lowestIDindex;
   
   if(numCusts==0) return -1; // return -1 if database empty
   
   // assume first customer has the lowest id and check the rest
   lowestIDindex = 0;
   
   for (int i=1; i<numCusts; i++) {
      if(ci[i]<ci[lowestIDindex])
         lowestIDindex = i;
   }
   
   return ci[lowestIDindex].getID(); // return the lowest ID
}

// returns the highest total of all customers 
// (returns -1 if there are no customers in the database)
double CustomerDB::getBestTotal() const {
   double maxtotal;
       
   if(numCusts==0) return -1; // return -1 if database empty
   
   // assume first total is largest and then check the rest
   maxtotal = ci[0].getTotal();  // **must** use getTotal
   
   for(int i=1;i<numCusts;i++) {
      if(ci[i].getTotal()>maxtotal) // use getTotal
         maxtotal=ci[i].getTotal(); // **must** use getTotal
   }
   
   return maxtotal;
}

// prints (to cout) the earliest purchase date of all customers 
// (prints 31 12 2099 if there are no customers in the database)
void CustomerDB::outputFirstDate() const {
   Date max(31,12,2099); 
   
   cout << "The first purchase date is: ";
   
   for (int i=0; i<numCusts; i++) {
      if(ci[i].getDate().compareTo(max)<0) // **must** use getDate
         max = ci[i].getDate(); // **must** use getDate
   }
   max.write(cout);
   cout << endl;
}

// returns the customer name that's first in case insensitive alphabetical order 
// (returns "" if there are no customers in the database)
String2002 CustomerDB::getFirstName() const {
   String2002 lowerFirstName, firstName, lowerName, name;
   
   if (numCusts==0) return ""; // return empty string if no customers
   
   // start with index 0 as the first name (convert to lower case)
   name = ci[0].getName(); // **must** use getName
   lowerFirstName = name;
   firstName = name;
   for(int i=0;i<(int)lowerFirstName.length();i++)
      lowerFirstName[i] = tolower(lowerFirstName[i]);
   
   // go through the rest, checking to see if each (converted to lower
   // case) is the first one so far
   for(int i=1; i<numCusts; i++) {
      name = ci[i].getName(); // **must** use getName
      lowerName = name;
      for(int j=0;j<(int)lowerName.length();j++)
         lowerName[j] = tolower(lowerName[j]);
      if(lowerName<lowerFirstName) {
         lowerFirstName=lowerName; // case insensitive lowest (in all lower case)
         firstName=name; // original name that is first so far
      }
   }
   
   return firstName; // returns the first name
}

// These two methods make it possible to "walk through" the customers in a
// customer database.  The customers may be returned in any order.  There is no
// guarantee that they will be returned in numerical order, in the order in
// which they were entered, or any other particular order.  "startWalk" may
// be called at any time.  If returns true on success (customer obtained) and
// false on failure (database empty).  If it returns true, it "returns" a customer 
// by reference.  "continueWalk" may only be called if
//       1/. the database has not been modified since a walk was
//           begun by calling startWalk AND
//       2/. the last call to startWalk or ContinueWalk returned true
// If these conditions are not met, "continueWalk" quits.
// It returns true on success (customer obtained) and false on
// failure (no more customers).  If it returns true, it "returns" a customer 
// by reference.
bool CustomerDB::startWalk (Customer &currentCustomer) {    
   if (numCusts == 0) return false; // database empty

   walkInProgress = true; walkPosition = 0;
   
   currentCustomer = ci[walkPosition]; // return first customer 
   
   return true;
}

bool CustomerDB::continueWalk (Customer &currentCustomer) {
   if (!walkInProgress)  // change made during walk so abort
      quit("CustomerDB::continueWalk - invalid call\n");

   if (++walkPosition == numCusts) {
      walkInProgress = false; // we've come to the end of the road
      return false;
   }
   currentCustomer = ci[walkPosition]; // return next customer 
   
   return true;
}