import java.util.Scanner;
import cs2030.simulator.Event;
import cs2030.simulator.Customer;
import cs2030.simulator.EventComparator;
import cs2030.simulator.EventManager;
import cs2030.simulator.ArrivalEvent;



public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int seed = sc.nextInt();
        int numServers = sc.nextInt();
        int numCustomer = sc.nextInt();
        double arrivalRate = sc.nextDouble();
        double svcRate = sc.nextDouble();
        double restRate = 1.0;

        EventManager eventManager = new EventManager(numServers, numCustomer,
            seed,arrivalRate,svcRate,restRate);
        eventManager.doService();
    }
}

package cs2030.simulator;
import java.util.PriorityQueue;

public class EventManager {
    Server [] servers;
    PriorityQueue<Event> events;
    Statistics statistics = new Statistics();
    RandomGenerator gen;

    public EventManager (int numServers, int numCustomer,
        int seed, double arrivalRate, double svcRate, double restRate) {
        this.events = new PriorityQueue<>(new EventComparator());
        this.gen = new RandomGenerator(seed, arrivalRate,svcRate,restRate);
        double time = 0;
        Customer customer = new Customer(time);
        ArrivalEvent tempEvent = new ArrivalEvent(customer,time);
        events.add(tempEvent);
        for (int i = 0;i < numCustomer-1;i++) {
            double x = gen.genInterArrivalTime();
            time += x;
            customer = new Customer(time);
            tempEvent = new ArrivalEvent(customer,time);
            events.add(tempEvent);
        }
        this.servers = new Server [numServers];
        for (int i = 0;i < numServers;i++){
            this.servers[i] = new Server();
        }
    }

    public void doService(){
        while (events.size() > 0){
            Event firstEvent = getFirstEvent();
            System.out.println(firstEvent);
            Event newEvent = firstEvent.getNextEvent(servers,gen);
            if (newEvent != null){
                newEvent.updateStatistics(statistics);
                events.add(newEvent);
            }

        }
        System.out.println(statistics);
    }

    public Event getFirstEvent() {
        return events.poll();
    }
}

package cs2030.simulator;

public class Customer {
    private static int counter = 1;
    private final int customerID;
    private final double time;

    public Customer(double time) {
        this.customerID = counter;
        this.time = time;
        counter++;
    }

    public int getCustomerID() {
        return this.customerID;
    }

    public double getTime() {
        return this.time;
    }

}

package cs2030.simulator;

class Statistics {
    private double waitingTime = 0;
    private int numLeft = 0;
    private int numServed = 0;

    public Statistics(){}

    public void increaseServed() {
        numServed++;
    }

    public void increaseWaitingTime(double time) {
        waitingTime += time;
    }

    public void increaseLeft() {
        numLeft++;
    }

    public String toString() {
        double x = waitingTime / numServed;
        return '[' + String.format("%.3f",x) + ' ' +
            numServed + ' ' + numLeft + ']';
    }
}

package cs2030.simulator;

class Server {
    private static int counter = 1;
    private int serverID;
    private Event served = null;
    private Event wait = null;

    public Server() {
        this.serverID = counter;
        counter++;
    }

    public int getServerID() {
        return this.serverID;
    }

    public void setServedEvent(Event newEvent) {
        this.served = newEvent;
    }
    public void setWaitEvent (Event newEvent) {
        this.wait = newEvent;
    }

    public boolean canTakeServedEvent() {
        return (served == null && wait == null);
    }

    public boolean canTakeWaitEvent() {
        return (served != null && wait == null);
    }

    public void flushDoneEvent(DoneEvent event) {
        if (served != null) {
            served = null;
        }
        if (wait != null) {
            served = wait;
            wait = null;
        }
    }

    public double getDoneTime() {
        return this.served.getTime();
    }
}

package cs2030.simulator;
import java.util.Comparator;


public class EventComparator implements Comparator<Event> {
    public int compare(Event e1, Event e2)  {
        if (e1.getTime() < e2.getTime()) {
            return -1;
        } else if (e1.getTime() > e2.getTime()) {
            return 1;
        } else if (e1.getCustomerID() < e2.getCustomerID()) {
            return -1;
        } else if (e1.getCustomerID() > e2.getCustomerID()) {
            return 1;
        } else {
            System.out.println("Bug with code, please check");
            return 0;
        }

    }
}

package cs2030.simulator;

public abstract class Event {
    private final Customer customer;
    private final double time;

    public Event(Customer customer, double time) {
        this.customer = customer;
        this.time = time;
    }

    public abstract Event getNextEvent(Server [] servers,RandomGenerator gen);

    public abstract void updateStatistics(Statistics statistics);

    public Customer getCustomer() {
        return this.customer;
    }

    public int getCustomerID() {
        return this.customer.getCustomerID();
    }

    public double getTime() {
        return this.time;
    }
}

package cs2030.simulator;

public class ArrivalEvent extends Event {
    public ArrivalEvent(Customer customer, double time) {
        super(customer, time);
    }

    public Event getNextEvent(Server [] servers,RandomGenerator gen) {
        Server freeServer = getFreeServer(servers);
        if (freeServer == null) {
            return createLeaveEvent();
        } else if (freeServer.canTakeServedEvent()) {
            ServedEvent newEvent = createServedEvent(freeServer);
            freeServer.setServedEvent(newEvent);
            return newEvent;
        } else if (freeServer.canTakeWaitEvent()) {
            WaitEvent newEvent = createWaitEvent(freeServer);
            freeServer.setWaitEvent(newEvent);
            return newEvent;
        } else {
            System.out.println("Bug in ArrivalEvents");
            return null;
        }
    }


    public LeaveEvent createLeaveEvent() {
        return new LeaveEvent(this.getCustomer(),this.getTime());
    }

    public ServedEvent createServedEvent(Server freeServer) {
        return new ServedEvent(this.getCustomer(),this.getTime(),freeServer);
    }

    public WaitEvent createWaitEvent(Server freeServer) {
        return new WaitEvent(this.getCustomer(),this.getTime(),freeServer);
    }

    public void updateStatistics(Statistics statistics) {
        return;
    }

    public Server getFreeServer(Server[] servers) {
        boolean hasFoundSlots = false;
        Server choiceServer = null;
        for (int i = 0; i < servers.length;i++) {
            Server newServer = servers[i];
            if (newServer.canTakeServedEvent()) {
                return newServer;
            } else if (newServer.canTakeWaitEvent() && !hasFoundSlots) {
                choiceServer = newServer;
                hasFoundSlots = true;
            }
        }
        if (hasFoundSlots == false) {
            return null;
        } else {
            return choiceServer;
        }
    }

    public String toString() {
        return String.format("%.3f",this.getTime()) + ' ' +
        this.getCustomerID() + " arrives";
    }
}

package cs2030.simulator;

class DoneEvent extends Event {
    private Server server;

    public DoneEvent(Customer customer, double time, Server server) {
        super(customer,time);
        this.server = server;
    }

    public Event getNextEvent(Server [] servers,RandomGenerator gen) {
        this.server.flushDoneEvent(this);
        return null;
    }

    public void updateStatistics(Statistics statistics) {
        return;
    }

    public String toString() {
        return String.format("%.3f",this.getTime()) +
            ' ' + this.getCustomerID() + " done serving by " +
            server.getServerID();
    }

}

package cs2030.simulator;

class WaitEvent extends Event{
    private Server server;

    public WaitEvent(Customer customer, double time, Server server){
        super(customer,time);
        this.server = server;
    }

    public ServedEvent getNextEvent(Server [] servers,RandomGenerator gen){
        if (!this.server.canTakeWaitEvent()){
            ServedEvent newEvent = new ServedEvent(this.getCustomer(),
                this.server.getDoneTime(), this.server);
            this.server.setWaitEvent(newEvent);
            return newEvent;
        }
        return null;
    }

    public void updateStatistics(Statistics statistics){
        return ;
    }

    public String toString(){
        return (String.format("%.3f",this.getTime()) +
            ' ' + this.getCustomerID() + " waits to be served by " +
            server.getServerID());
    }

}

package cs2030.simulator;

class ServedEvent extends Event {
    private Server server;

    public ServedEvent(Customer customer, double time, Server server) {
        super(customer,time);
        this.server=server;
    }

    public DoneEvent getNextEvent(Server [] servers,RandomGenerator gen) {
        double x = gen.genServiceTime​();
        DoneEvent newEvent = new DoneEvent(this.getCustomer(),
            this.getTime() + x,this.server);
        this.server.setServedEvent(newEvent);
        return newEvent;
    }

    public void updateStatistics(Statistics statistics) {
        statistics.increaseServed();
        statistics.increaseWaitingTime(this.getTime() - this.getCustomer().getTime());
    }

    public String toString() {
        return (String.format("%.3f",this.getTime()) + ' ' +
            this.getCustomerID() + " served by " + server.getServerID());
    }
}

package cs2030.simulator;

class LeaveEvent extends Event {
    private Server server;

    public LeaveEvent(Customer customer, double time) {
        super(customer,time);
    }

    public Event getNextEvent(Server [] servers, RandomGenerator gen) {
        return null;
    }


    public void updateStatistics(Statistics statistics) {
        statistics.increaseLeft();
    }

    public String toString() {
        return String.format("%.3f",this.getTime()) +
            ' ' + this.getCustomerID() + " leaves";
    }

}

1
1
5
1.0
1.0


0.000 1 arrives
0.000 1 served by 1
0.313 1 done serving by 1
0.314 2 arrives
0.314 2 served by 1
0.417 2 done serving by 1
1.205 3 arrives
1.205 3 served by 1
1.904 3 done serving by 1
2.776 4 arrives
2.776 4 served by 1
2.791 4 done serving by 1
3.877 5 arrives
3.877 5 served by 1
4.031 5 done serving by 1
[0.000 5 0]


1
2
10
1.0
1.0

0.000 1 arrives
0.000 1 served by 1
0.313 1 done serving by 1
0.314 2 arrives
0.314 2 served by 1
0.417 2 done serving by 1
1.205 3 arrives
1.205 3 served by 1
1.904 3 done serving by 1
2.776 4 arrives
2.776 4 served by 1
2.791 4 done serving by 1
3.877 5 arrives
3.877 5 served by 1
3.910 6 arrives
3.910 6 served by 2
3.922 6 done serving by 2
4.031 5 done serving by 1
9.006 7 arrives
9.006 7 served by 1
9.043 8 arrives
9.043 8 served by 2
9.105 9 arrives
9.105 9 waits to be served by 1
9.160 10 arrives
9.160 10 waits to be served by 2
10.484 7 done serving by 1
10.484 9 served by 1
10.781 9 done serving by 1
11.636 8 done serving by 2
11.636 10 served by 2
11.688 10 done serving by 2
[0.386 10 0]