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

// private method to enlarge database by CAPACITY_INCREMENT
// Hint: It will make your life easier if you move head back to 0 when you do this!
void CustomerDB::enlargeDB() {
   Customer *temp; // temporary array
   
   // allocate new array that is CAPACITY_INCREMENT larger
   capacity += CAPACITY_INCREMENT;
   temp = new Customer[capacity];
   
   // copy over values 
   for(int i=0;i<numCusts;i++) 
      temp[i] = ci[(head+i)%numCusts];
      
   // delete the old array 
   delete [] ci;
   
   // use the new array, setting head and tail
   ci = temp;
   head = 0; tail = numCusts;     
}

// private method to delete database; used by destructor and assignment
void CustomerDB::deleteDB() {
   delete [] ci; // delete the dynamically allocated array (it's never NULL)
}
   
   
// private method to copy database; used by copy constructor and assignment
void CustomerDB::copyDB(const CustomerDB &otherCustDB) {
     
   numCusts = otherCustDB.numCusts; // set number of customers
   capacity = otherCustDB.capacity; // set capacity
   
   ci = new Customer[capacity]; // new array
      
   // copy over contents of array
   // note that the copy will always have head at 0
   for (int i=0;i<numCusts;i++) 
      ci[i] = otherCustDB.ci[(otherCustDB.head+i)%capacity];
      
   // set head and tail
   head = 0; tail = numCusts;
   
   walkInProgress = false; // database changed
}

// the constructor creates an empty database
CustomerDB::CustomerDB() {
   numCusts=0; // no customers yet 
   capacity = DEFAULT_CAPACITY;
   ci = new Customer[capacity]; // empty array
   head = tail = 0; // head and tail both at 0 to start
   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) {
   
   for(int i=0;i<numCusts;i++) {  
      // **must** use == method in Customer class     
      if(ci[(head+i)%capacity]==newCust) return false; // Customer already in database
   }
   
   // if database full, enlarge it
   if(capacity==numCusts) enlargeDB();
   
   // insert new customer at end
   ci[tail] = newCust;
   tail = (tail+1)%capacity;
   
   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 (database
// is empty)
bool CustomerDB::remove() {
   
   if(numCusts==0) return false; // datbase empty
   
   // print customer info for the one being removed
   cout << "Customer removed: \n";
   ci[head].print();
   
   head = (head+1)%capacity;
   numCusts--;
         
   walkInProgress = false; // we've changed the database
   
   return true; // Customer removed
}

// 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[(head+i)%capacity].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[(head+i)%capacity].getID()==nid) return false; // new id already in use (must use getID)
   }
     
   for(int i=0;i<numCusts;i++) {
      if(ci[(head+i)%capacity].getID()==id) { // found the one we want to change
         ci[(head+i)%capacity].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[(head+i)%capacity].getID()==id) { // found the one we want to change so update total, use getID
         ci[(head+i)%capacity].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[(head+i)%capacity].getID()==id) { // found the one we want to change so update total, use getID
         temp = ci[(head+i)%capacity].getDate(); // **must** use getDate and setDate methods
         temp.move(days); // adjust old date
         ci[(head+i)%capacity].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[(head+i)%capacity].getID()==id) { // found the one we want to change so update total, use getID
         ci[(head+i)%capacity].setName(ci[(head+i)%capacity].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 = head;
   
   for (int i=1; i<numCusts; i++) {
      if(ci[(head+i)%capacity]<ci[lowestIDindex])
         lowestIDindex = (head+i)%capacity;
   }
   
   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[head].getTotal();  // **must** use getTotal
   
   for(int i=1;i<numCusts;i++) {
      if(ci[(head+i)%capacity].getTotal()>maxtotal) // use getTotal
         maxtotal=ci[(head+i)%capacity].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[(head+i)%capacity].getDate().compareTo(max)<0) // **must** use getDate
         max = ci[(head+i)%capacity].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[head].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[(head+i)%capacity].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[(head+walkPosition)%capacity]; // 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[(head+walkPosition)%capacity]; // return next customer 
   
   return true;
}