void Manager::run() {
 while (_event_queue.size() != 0) {
  _current_event = _event_queue.front();
  if (_current_event->occur_time >= _total_serve_time)//超出营业时间
   break;
  if(_customer_queue.size() == 0 && _event_queue.size() <= _service_num)//生成新的顾客到达事件
  {
   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)//处理顾客到达事件
   customer_arrived();
  else if (_current_event->event_type == EventType::DEPARTURE)//处理顾客离开事件
   customer_departure();
 }
} 

 void Manager::generate_arrived_event(int& current_time) {//生成单位时间内的顾客到达事件并入队，current_time是共享的
 Event* event;
 int customer_per_minute = Random::uniform(RANDOM_PER_MINUTE);//单位时间内随机到达的顾客数量，至少为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是银行的总营业时间
  generate_arrived_event(_generate_arrived_time);
 } 

 _generate_arrived_time = 0;//依旧是以时间顺序生成顾客到达事件
 while(_generate_arrived_time < INIT_ARRIVIED_EVENT_NUM) {//选择合适的值，使最初生成的顾客到达事件略多于服务窗口数量，保证服务窗口满载且有等待顾客即可
  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();//服务窗口置为“忙”
 _services[service_index].set_service_start_time(current_time);//服务开始时间
 _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();//获取空闲的服务窗口，返回-1说明未找到
 int current_time = _current_event->occur_time;
 Customer* customer = new Customer(current_time);//顾客到达事件发生时间即为顾客到达时间， 顾客接受服务的时长随机
 _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;//顾客离开的服务窗口

 _customer_stay_time += current_time -
     _services[service_index].get_customer_arrive_time();//统计顾客在银行的滞留时间
 ++_total_served_customer_num;//接受服务的顾客数目加1
 _services[service_index].set_idle();
 _event_queue.dequeue();

 if(_customer_queue.size() > 0) {
  service_index = get_idle_service_index();//有顾客离开，必然可以获得1个空闲服务窗口，这里获取最小序号的服务窗口
  generate_departure_event(service_index, current_time);
 }
} 

 void Manager::end() {
 for (int i = 0; i < _service_num; i++) {
  if (!_services[i].is_idle()) {//统计正在接受服务的顾客的信息
   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;
  }
 }

 //释放动态申请的内存
 _customer_queue.clear();
 _event_queue.clear();
 delete[] _services;
} 

 //声明使用greater<Event>作为比较函数的优先队列
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的实现，都是通过'<'来完成余下的比较操作符
 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;//通过'<'实现'>'的功能
}

#endif //BANKQUEUE_EVENT_QUEUE_H 

 //声明使用EventComp作为比较函数的优先队列
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;
}