void Manager::run() {
 while (_event_queue.size() != 0) {
  _current_event = _event_queue.front();
  if (_current_event->occur_time >= _total_serve_time)//超出營業(yè)時(shí)間
   break;
  if(_customer_queue.size() == 0 && _event_queue.size() <= _service_num)//生成新的顧客到達(dá)事件
  {
   generate_arrived_event(_generate_arrived_time);
   _current_event = _event_queue.front();//update current event, deal it with order
  }

  if (_current_event->event_type == EventType::ARRIVIED)//處理顧客到達(dá)事件
   customer_arrived();
  else if (_current_event->event_type == EventType::DEPARTURE)//處理顧客離開事件
   customer_departure();
 }
} 

 void Manager::generate_arrived_event(int& current_time) {//生成單位時(shí)間內(nèi)的顧客到達(dá)事件并入隊(duì)，current_time是共享的
 Event* event;
 int customer_per_minute = Random::uniform(RANDOM_PER_MINUTE);//單位時(shí)間內(nèi)隨機(jī)到達(dá)的顧客數(shù)量，至少為1例
 while (customer_per_minute > 0) {
  event = new Event(current_time);
  _event_queue.enqueue(event);
  --customer_per_minute;
 }
 ++current_time;
 }
 

 _generate_arrived_time = 0;
 while(_generate_arrived_time < _total_serve_time) { //_total_serve_time是銀行的總營業(yè)時(shí)間
  generate_arrived_event(_generate_arrived_time);
 } 

 _generate_arrived_time = 0;//依舊是以時(shí)間順序生成顧客到達(dá)事件
 while(_generate_arrived_time < INIT_ARRIVIED_EVENT_NUM) {//選擇合適的值，使最初生成的顧客到達(dá)事件略多于服務(wù)窗口數(shù)量，保證服務(wù)窗口滿載且有等待顧客即可
  generate_arrived_event(_generate_arrived_time);
 } 

 if(_customer_queue.empty() && _event_queue.size() <= _service_num)
{
 generate_arrived_event(_generate_arrived_time);
 _current_event = &_event_queue.top();//update current event, deal it with order
} 

 void Manager::generate_departure_event(int service_index, int current_time) {
 _services[service_index].serve_customer(*_customer_queue.front());
 _services[service_index].set_busy();//服務(wù)窗口置為“忙”
 _services[service_index].set_service_start_time(current_time);//服務(wù)開始時(shí)間
 _customer_queue.dequeue();

 int duration = _services[service_index].get_customer_duration();
 Event* event = new Event(current_time + duration, EventType::DEPARTURE, service_index);//生成顧客離開事件
 _event_queue.enqueue(event);
} 

void Manager::customer_arrived() {
 int idle_service_num = get_idle_service_index();//獲取空閑的服務(wù)窗口，返回-1說明未找到
 int current_time = _current_event->occur_time;
 Customer* customer = new Customer(current_time);//顧客到達(dá)事件發(fā)生時(shí)間即為顧客到達(dá)時(shí)間， 顧客接受服務(wù)的時(shí)長隨機(jī)
 _customer_queue.enqueue(customer);
 _event_queue.dequeue();
  
 if (idle_service_num != -1)
  generate_departure_event(idle_service_num, current_time);
} 

 void Manager::customer_departure() {
 int current_time = _current_event->occur_time;
 int service_index = _current_event->service_index;//顧客離開的服務(wù)窗口

 _customer_stay_time += current_time -
     _services[service_index].get_customer_arrive_time();//統(tǒng)計(jì)顧客在銀行的滯留時(shí)間
 ++_total_served_customer_num;//接受服務(wù)的顧客數(shù)目加1
 _services[service_index].set_idle();
 _event_queue.dequeue();

 if(_customer_queue.size() > 0) {
  service_index = get_idle_service_index();//有顧客離開，必然可以獲得1個(gè)空閑服務(wù)窗口，這里獲取最小序號(hào)的服務(wù)窗口
  generate_departure_event(service_index, current_time);
 }
} 

 void Manager::end() {
 for (int i = 0; i < _service_num; i++) {
  if (!_services[i].is_idle()) {//統(tǒng)計(jì)正在接受服務(wù)的顧客的信息
   int service_start_time = _services[i].get_service_start_time();
   int arrive_time = _services[i].get_customer_arrive_time();
   int duration = _services[i].get_customer_duration();

   _customer_stay_time += service_start_time + duration - arrive_time;
   ++_total_served_customer_num;
  }
 }

 //釋放動(dòng)態(tài)申請(qǐng)的內(nèi)存
 _customer_queue.clear();
 _event_queue.clear();
 delete[] _services;
} 

 //聲明使用greater<Event>作為比較函數(shù)的優(yōu)先隊(duì)列
std::priority_queue<Event, std::vector<Event>, std::greater<Event>> _event_queue; //event_queue.h

#ifndef BANKQUEUE_EVENT_QUEUE_H
#define BANKQUEUE_EVENT_QUEUE_H

#include "random.h"

enum class EventType : int {
 ARRIVIED,
 DEPARTURE
};

class Event {
 public:
 Event():occur_time(Random::uniform(RANDOM_PARAMETER)),
     event_type(EventType::ARRIVIED),
     service_index(-1),
     next(nullptr){}

 Event(int occur_time):occur_time(occur_time),
     event_type(EventType::ARRIVIED),
     service_index(-1),
     next(nullptr){}
 Event(int occur_time, EventType event_type, int service_index):
     occur_time(occur_time),
     event_type(event_type),
     service_index(service_index),
     next(nullptr) {}

 friend bool operator< (const Event& event1, const Event& event2);//模仿STL的實(shí)現(xiàn)，都是通過'<'來完成余下的比較操作符
 friend bool operator> (const Event& event1, const Event& event2);//供`greater<Event>`使用

 public:
 int occur_time;
 int service_index;
 EventType event_type;
 Event *next;
};

inline bool operator< (const Event& event1, const Event& event2) {
 return event1.occur_time < event2.occur_time;
}

inline bool operator> (const Event& event1, const Event& event2) {
 return event2 < event1;//通過'<'實(shí)現(xiàn)'>'的功能
}

#endif //BANKQUEUE_EVENT_QUEUE_H 

 //聲明使用EventComp作為比較函數(shù)的優(yōu)先隊(duì)列
std::priority_queue<Event, std::vector<Event>, EventComp> _event_queue; struct EventComp
{
 bool operator()(const Event& lhs, const Event& rhs) const
 {
  return lhs.occur_time > rhs.occur_time;//occur_time是公有的，若是私有的，則需要提供接口
 }
}; 

void Queue<Event>::enqueue(Event* event) {

 Event *cur = _front, *prev = nullptr;

 while (cur != nullptr) {
  if (cur->occur_time < event->occur_time) {
   prev = cur;
   cur = cur->next;
  }
  else
   break;
 }

 if (prev == nullptr) {
  event->next = _front;
  _front = event;
  if (_rear == nullptr)
   _rear = event;//_rear is useless to Event queue
 }
 else {
  event->next = prev->next;
  prev->next = event;
  if (prev == _rear)
   _rear = event;
 }
 ++length;
}