// TODO
// add controls for:
// serverRate
// customerArrivalRate
// numServers

// An applet to simulate an M/M/n queue
// which means: arrival rate/service time/number of servers

// todo: have arrival rate of one queue, need to add:
//   number of servers
//   service time modelling

float customerRate = 20; // 1 means 1 per second
float serverRate = 3;

int numServers = 5;
int numCustomers=0;

Queue[] queues;

int numQueues = 150;

void setup(){
  queues = new Queue[numQueues];
  for(int qu=0; qu<numQueues; qu++){
    queues[qu] = new Queue(customerRate, numServers, serverRate, 100, 100+(qu*2), 10);
  }
  
  size(700,500);
  background(255);
  stroke(0);

  frameRate(30);
}

void draw(){
  
  background(255);  
  
  for(int x=0; x<numQueues; x++){  
    if(queues[x].seeIfWeNeedANewCustomer()){
       queues[x].addNewCustomer();
    }
  
    queues[x].seeHowServingIsGoing();
    queues[x].seeIfWeCanServeAnyone();
  
    queues[x].draw();
  }
  
}



class Queue{
  Customer[] customers;
  Server[] servers;
 
 
  float t, last, lastt;
  float rate;
  int numCustomers=0;
  
  // Display
  int spacing;
  int xPos,yPos;
  
   Queue(float rate, int numServers, float serverRate, int x, int y, int sp){
      this.rate = rate;
      customers = new Customer[500];
      servers = new Server[numServers];

      for(int s=0; s<numServers; s++){
       servers[s]=new Server(serverRate); 
      }

      last = 0;
      t = findt(rate);
      
      xPos = x;
      yPos = y;
      spacing = sp;
      
   }
   
   int getNumberOfCustomers(){
      return numCustomers; 
   }
   
   void addNewCustomer() {
       if(numCustomers<500){
         customers[numCustomers++] = new Customer(numCustomers, xPos + (numCustomers*spacing), 
               yPos, spacing);
       }
       
   }
   
   Boolean seeIfWeNeedANewCustomer(){
    int currentTime = millis();   
    if(currentTime-last > t*1000){
      last = currentTime;
      lastt = t;
      t = findt(rate);
      return true;
    }else{  
      return false; 
    }
   }
   
   // Is there anyone at the front of the queue
   // And is there a free server
   void seeIfWeCanServeAnyone() {
   
        // iterate through servers and allocate customers 
        for(int s=0; s<servers.length; s++){
           if(servers[s].isFree()){
              // let's allocate a customer
              if(numCustomers > 0){
                servers[s].allocateCustomer(customers[0]);
                shuffleCustomersUp();
              }
           } 
        }

     
   }
   
   void shuffleCustomersUp(){
     // we want to get rid of the first entry in the array
     
     Customer[] nC = new Customer[500];
     
     // put all the customers we have in an array
     for(int c=0; c<numCustomers; c++){
       if(c>0){
         nC[c-1] = customers[c];
       }
     }
     
     numCustomers--;
     customers = nC;
     
     // As we've less customers, need to tell them all they should be further along
     for(int c=0; c<numCustomers; c++){
        customers[c].moveDown(); 
     }
     
   }
   
   
   void seeHowServingIsGoing(){
      for(int s=0; s<servers.length; s++){
         servers[s].seeIfDoneServingCustomer();
      } 
   }
   
   
   
   
   void draw(){
      for(int c=0; c<numCustomers; c++){
       customers[c].draw();
      } 
      
      for(int s=0; s<servers.length; s++){
       servers[s].draw();
      }       
   }
 
}

// Need to generate new customers at a certain rate
class Customer {
  
  int index; 
  
  // A customer can get allocated a server, and vice-versa
  Boolean served;
  Boolean done;  
  int xPos, yPos;
  int xDest, yDest;
  int spacing;
  
  Customer(int ind, int x, int y, int sp){
    index = ind;
    
    served = false;
    done = false;
    
    xPos = x;
    yPos = y;
    
    spacing = sp;
    
    xDest = xPos;
    yDest = yPos;
    
  }
  
  void setServed(){
   served = true; 
   xDest = -10;
  }
  
 
  void moveDown(){
     xDest = xDest - spacing; 
  }
  
  
  void draw(){
   if(xPos > xDest){

     // if customer's been served, we just want to shuffle him off fast
    if(served){
       xPos = xPos-1;
    }else{
       xPos = xPos - 2; 
    }
   }
   
   if(served){
     stroke(255,0,0);
   }else{
     stroke(0,0,0);
   }
   
   point(xPos, yPos); 
   //point(xPos+1, yPos);    
  }
  
}


class Server {
  // Each server can serve at most one customer at a time
  Customer cm;
  Boolean busy;
  
  float rate;
  float t, last, lastt;
  
  Server(float r) {
   busy = false; 
   rate = r;
      last = 0;
      t = findt(rate);   
  }
  
  void allocateCustomer(Customer c){

     cm = c;
     cm.setServed();
     busy = true; 
  }
  
  Boolean seeIfDoneServingCustomer(){
    Boolean areWe = areWeDone();
    if(areWe){
      busy = false;
    }
    
    return areWe;
  }
  
  Boolean isFree(){
     return (! busy); 
  }
  
   Boolean areWeDone(){
    int currentTime = millis();   
    if(currentTime-last > t*1000){
      last = currentTime;
      lastt = t;
      t = findt(rate);
      return true;
    }else{  
      return false; 
    }
   }  
   
   void draw(){
      if(busy){
         cm.draw();
      } 
   }
  
}



// function to generate a waiting time
float findt(float rate){
  return  -1/rate * (float)Math.log(1 - Math.random());
}