// bank.cpp -- using the Queue interface
/*
A queue is an abstract data type (ADT) that holds an ordered sequence of items.
New items are added to the rear of the queue, and items can be removed from the front.
The queue is a FIFO (first in, first out) structure.
The items in the queue will be customers. A representative tells you
that, on average, a third of the customers will take one minute to be processed, a third will
take two minutes, and a third will take three minutes. Furthermore, customers arrive at
random intervals, but the average number of customers per hour is fairly constant.
The project will be to design a class representing customers and to put
together a program that simulates the interactions between customers and the queue.

A Queue Class
The list the attributes of the kind of queue:
- A queue holds an ordered sequence of items.
- A queue has a limit on the number of items it can hold.
- You should be able to create an empty queue.
- You should be able to check whether a queue is empty.
- You should be able to check whether a queue is full.
- You should be able to add an item to the end of a queue.
- You should be able to remove an item from the front of a queue.
- You should be able to determine the number of items in the queue.
To implement Node  of the queue is better the use of a linked list. A linked list consists
of a sequence of nodes. Each node contains the information to be held in the list, plus
a pointer to the next node in the list.
For the queue in this program, each data part is a type Item value, and
you can use a structure to represent a node:
struct Node
{
 Item item; // data stored in the node
 struct Node * next; // pointer to next node
};

The Customer Class
A customer has many properties, such as a name, account numbers, and account balances.
However, the only properties you need for the simulation are when a customer joins
the queue and the time required for the customer’s transaction.
When the simulation produces a new customer, the program should create a new customer
object, storing in it the customer’s time of arrival and a randomly generated value
for the transaction time.
When the customer reaches the front of the queue, the program should note the time
and subtract the queue joining time to get the customer’s waiting time.

The Global Simulation
The program should allow the user to enter three quantities:
- the maximum queue size,
- the number of hours the program will simulate,
- and the average number of customers per hour.
The program should use a loop in which each cycle represents one minute.
During each minute cycle, the program should do the following:
1. Determine whether a new customer has arrived. If so, add the customer to the
queue if there is room; otherwise, turn the customer away.
2. If no one is being processed, take the first person from the queue. Determine how
long the person has been waiting and set a wait_time counter to the processing
time that the new customer will need.
3. If a customer is being processed, decrement the wait_time counter by one minute.
4. Track various quantities, such as the number of customers served, the number of
customers turned away, cumulative time spent waiting in line, and cumulative
queue length.
When the simulation cycle is finished, the program should report various statistical
findings.
*/


#include <iostream>
#include <cstdlib> // for rand() and srand()
#include <ctime>   // for time()
#include "queue.h"
const int MIN_PER_HR = 60;

bool newcustomer(double x); // is there a new customer?

int main()
{
    using std::cin;
    using std::cout;
    using std::endl;
    using std::ios_base;
// setting things up
    std::srand(std::time(0));    //  random initializing of rand()

    cout << "Case Study: Bank Automatic Teller\n";
    cout << "Enter maximum size of queue: ";
    int qs;
    cin >> qs;
    Queue line(qs);         // line queue holds up to qs people

    cout << "Enter the number of simulation hours: ";
    int hours;              //  hours of simulation
    cin >> hours;
    // simulation will run 1 cycle per minute
    long cyclelimit = MIN_PER_HR * hours; // # of cycles

    cout << "Enter the average number of customers per hour: ";
    double perhour;         //  average # of arrival per hour
    cin >> perhour;
    double min_per_cust;    //  average time between arrivals
    min_per_cust = MIN_PER_HR / perhour;

    Item temp;              //  new customer data
    long turnaways = 0;     //  turned away by full queue
    long customers = 0;     //  joined the queue
    long served = 0;        //  served during the simulation
    long sum_line = 0;      //  cumulative line length
    int wait_time = 0;      //  time until autoteller is free
    long line_wait = 0;     //  cumulative time in line


// running the simulation
    for (int cycle = 0; cycle < cyclelimit; cycle++)
    {
        if (newcustomer(min_per_cust))  // have newcomer
        {
            if (line.isfull())
                turnaways++;
            else
            {
                customers++;
                temp.set(cycle);    // cycle = time of arrival
                line.enqueue(temp); // add newcomer to line
            }
        }
        if (wait_time <= 0 && !line.isempty())
        {
            line.dequeue (temp);      // attend next customer
            wait_time = temp.ptime(); // for wait_time minutes
            line_wait += cycle - temp.when();
            served++;
        }
        if (wait_time > 0)
            wait_time--;
        sum_line += line.queuecount();
    }

// reporting results
    if (customers > 0)
    {
        cout << "customers accepted: " << customers << endl;
        cout << "  customers served: " << served << endl;
        cout << "         turnaways: " << turnaways << endl;
        cout << "average queue size: ";
        cout.precision(2);
        cout.setf(ios_base::fixed, ios_base::floatfield);
        cout << (double) sum_line / cyclelimit << endl;
        cout << " average wait time: "
             << (double) line_wait / served << " minutes\n";
    }
    else
        cout << "No customers!\n";
    cout << "Done!\n";

    return 0;
}

//  x = average time, in minutes, between customers
//  return value is true if customer shows up this minute
bool newcustomer(double x)
{
    return (std::rand() * x / RAND_MAX < 1);
}