// Purpose.  Chain of Responsibility design pattern lab
// 
// Problem.  Four Slot objects are being used, and the client has to know
// about and interact with all of them.  It would be preferable to decouple
// the client from its many servers by encapsulating all the Slot objects
// in a single pipeline, or chain, abstraction.  The advantages are:
// "request handling" algorithms are hidden in the pipeline abstraction, and
// client complexity is reduced because it can now "launch and leave" all
// requests with the head of the pipeline and the pipeline "divides and
// conquers" the request across its collection of processing elements.
// 
// Assignment.
// o Add a Slot* data member to Slot that will point to each Slot's successor
//   in the chain
// o Modify the constructors for Slot, Quarter, Dime, Nickel, and Penny to
//   accept a Slot* and initialize the Slot* data member (use an "=0" default
//   argument)
// o Change accept() to delegate to the successor if the conditional expression
//   does not succeed (accept() can now have a void return type)
// o Add a report() member function to the Slots hierarchy that encapsulates
//   the functionality of the final four cout's in main().
// o Encapsulate the slots array set-up in a free function.  Create the "chain"
//   in this function and return it to main().
// o Change main() to eliminate all knowledge of, or interaction with, the
//   number and type of Slot objects.

#include <iostream.h>
#include <stdlib.h>
#include <time.h>

class Slot {
public:
   Slot( int val ) {
      value_ = val;
      count_ = 0; }
   int accept( int coin ) {
      if (coin == value_) {
         count_++;
         return 1; }
      return 0; }
   int getCount() {
      return count_; }
private:
   int  value_;
   int  count_;
};

class Quarter : public Slot {
public:
   Quarter() : Slot( 25 ) { }
};

class Dime : public Slot {
public:
   Dime() : Slot( 10 ) { }
};

class Nickel : public Slot {
public:
   Nickel() : Slot( 5 ) { }
};

class Penny : public Slot {
public:
   Penny() : Slot( 1 ) { }
};

int pickCoin()
{
   static int choices[4] = { 1, 5, 10, 25 };
   return choices[rand() % 4];
}

void main( void )
{
   Slot*    slots[4];
   slots[0] = new Quarter;
   slots[1] = new Dime;
   slots[2] = new Nickel;
   slots[3] = new Penny;
   int      i, coin, total;
   time_t   t;
   srand((unsigned) time(&t));

   for (i=0, total=0; i < 10; i++)
   {
      coin = pickCoin();
      cout << coin << " ";
      total += coin;
      for (int j=0; j < 4; j++)
         if (slots[j]->accept( coin )) break;
   }
   cout << "\ntotal deposited is $" << total/100 << "."
      << (total%100 < 10 ? "0" : "") << total%100 << endl;
   cout << "quarters - " << slots[0]->getCount() << endl;
   cout << "dimes    - " << slots[1]->getCount() << endl;
   cout << "nickels  - " << slots[2]->getCount() << endl;
   cout << "pennies  - " << slots[3]->getCount() << endl;
}

// 10 5 25 5 1 25 5 25 1 25 
// total deposited is $1.27
// quarters - 4
// dimes    - 1
// nickels  - 3
// pennies  - 2
// 
// 25 25 10 5 1 5 10 5 1 5 
// total deposited is $0.92
// quarters - 2
// dimes    - 2
// nickels  - 4
// pennies  - 2
// 
// 5 10 25 10 25 1 25 10 1 25 
// total deposited is $1.37
// quarters - 4
// dimes    - 3
// nickels  - 1
// pennies  - 2