Is the simulation code correct?

import random
from queue import Queue, PriorityQueue  # This is used to maintain the order of events in the simulation
import matplotlib.pyplot as plt

from tabulate import tabulate

# ******************************************************************************
# Constants
# ******************************************************************************

SERVICE = 10.0  # SERVICE is the average service time; service rate = 1/SERVICE
ARRIVAL = 5  # ARRIVAL is the average inter-arrival time; arrival rate = 1/ARRIVAL
LOAD = SERVICE / ARRIVAL  # This relationship holds for M/M/1
TYPE1 = 1
SIM_TIME = 500000
arrivals = 0
users = 0
# BusyServer = False  # True: server is currently busy; False: server is currently idle
MM1 = []


# ******************************************************************************
# To take the measurements
# ******************************************************************************
class Measure:
    def __init__(self, Narr, Ndep, NAveraegUser, OldTimeEvent, AverageDelay, Drop):
        self.arr = Narr  # number of arrivals
        self.dep = Ndep  # number of departures
        self.ut = NAveraegUser  # average number of users
        self.oldT = OldTimeEvent  # time of the last event
        self.delay = AverageDelay  # average delay of users
        self.drop = Drop  # number of users that were dropped


# ******************************************************************************
# Client
# ******************************************************************************
class Client:
    def __init__(self, type, arrival_time):
        self.type = type
        self.arrival_time = arrival_time


# ******************************************************************************
# Server
# ******************************************************************************
class Server(object):

    # constructor
    def __init__(self):
        # whether the server is idle or not
        self.idle = True


# ******************************************************************************
# MultiServer
# ******************************************************************************
class MultiServer:
    def __init__(self, num_servers):
        self.servers = [Server() for _ in range(num_servers)]

    def idle_server(self):  # It returns the first idle server, if one is available
        for server in self.servers:
            if server.idle:
                return server
        return None

    def busy_servers_count(self):  # The total number of busy servers
        return sum([1 for server in self.servers if not server.idle])


# ******************************************************************************

# arrivals *********************************************************************
def arrival(time, FES, queue, buffer_size, multi_server):
    global users  # to keep track of the number of clients currently being served by the server

    # cumulate statistics
    data.arr += 1
    data.ut += users * (time - data.oldT)
    data.oldT = time

    # sample the time until the next event
    inter_arrival = random.expovariate(lambd=1.0 / ARRIVAL)  # lambd is the parameter of the random.expovariate function

    # schedule the next arrival
    FES.put((time + inter_arrival, "arrival"))

    users += 1

    # create a record for the client
    client = Client(TYPE1, time)

    # check the buffer size before adding a new packet into the MM1 queue
    if len(queue) < buffer_size:
        queue.append(client)
    else:
        # increase the dropped packets count
        data.drop += 1
        users -= 1

    idle_server = multi_server.idle_server()
    if idle_server:
        idle_server.idle = False
        if users == 1:
            service_time = random.expovariate(1.0 / SERVICE)
            FES.put((time + service_time, "departure"))


# ******************************************************************************

# departures *******************************************************************
def departure(time, FES, queue, multi_server):
    global users

    # cumulate statistics
    data.dep += 1
    data.ut += users * (time - data.oldT)
    data.oldT = time

    # get the first element from the queue
    client = queue.pop(0)

    data.delay += (time - client.arrival_time)
    users -= 1

    idle_server = multi_server.idle_server()
    if users > 0 and idle_server:
        idle_server.idle = False
        service_time = random.expovariate(1.0 / SERVICE)
        FES.put((time + service_time, "departure"))
    else:
        #  finding the last server that is currently busy, and then setting its idle attribute to True to make it Free
        if multi_server.busy_servers_count() > 0:
            multi_server.servers[multi_server.busy_servers_count() - 1].idle = True



# ******************************************************************************
# the "main" of the simulation
# ******************************************************************************

def run_simulation(num_servers, buffer_size):
    global data, users

    random.seed(42)
    data = Measure(0, 0, 0, 0, 0, 0)
    users = 0
    time = 0
    FES = PriorityQueue()
    MM1 = []

    multi_server = MultiServer(num_servers)

    FES.put((0, "arrival"))

    while time < SIM_TIME:
        (time, event_type) = FES.get()

        if event_type == "arrival":
            arrival(time, FES, MM1, buffer_size, multi_server)
        elif event_type == "departure":
            departure(time, FES, MM1, multi_server)

    return data.ut / time, data.delay / data.dep, data.drop


# Simulation for different number of servers and buffer sizes
servers_list = [1, 2, 3, 4, 5]  # Different numbers of the possible servers
buffer_sizes = [5, 10, 15, 20, 25]  # Different numbers of the possible buffer size
num_trials = 3  # number of trials to average the results

avg_users_per_servers = []
avg_delay_per_servers = []
avg_drop_per_servers = []

avg_users_per_buffers = []
avg_delay_per_buffers = []
avg_drop_per_buffers = []

# Running simulation for different number of the servers assuming the buffer size is 10
for num_servers in servers_list:
    avg_users_trial = []
    avg_delay_trial = []
    avg_drop_trial = []

    for trial in range(num_trials):
        avg_users, avg_delay, avg_drop = run_simulation(num_servers, 10)
        avg_users_trial.append(avg_users)
        avg_delay_trial.append(avg_delay)
        avg_drop_trial.append(avg_drop)

    avg_users_per_servers.append(sum(avg_users_trial) / num_trials)
    avg_delay_per_servers.append(sum(avg_delay_trial) / num_trials)
    avg_drop_per_servers.append(sum(avg_drop_trial) / num_trials)

# Running simulation for different buffer size assuming we have only 2 servers
for buffer_size in buffer_sizes:
    avg_users_trial = []
    avg_delay_trial = []
    avg_drop_trial = []

    for trial in range(num_trials):
        avg_users, avg_delay, avg_drop = run_simulation(2, buffer_size)
        avg_users_trial.append(avg_users)
        avg_delay_trial.append(avg_delay)
        avg_drop_trial.append(avg_drop)

    avg_users_per_buffers.append(sum(avg_users_trial) / num_trials)
    avg_delay_per_buffers.append(sum(avg_delay_trial) / num_trials)
    avg_drop_per_buffers.append(sum(avg_drop_trial) / num_trials)

# Plotting the results
fig, axs = plt.subplots(2, 3, figsize=(15, 10))
axs[0, 0].plot(servers_list, avg_users_per_servers, marker='o')
axs[0, 1].plot(servers_list, avg_delay_per_servers, marker='o')
axs[0, 2].plot(servers_list, avg_drop_per_servers, marker='o')

axs[1, 0].plot(buffer_sizes, avg_users_per_buffers, marker='o')
axs[1, 1].plot(buffer_sizes, avg_delay_per_buffers, marker='o')
axs[1, 2].plot(buffer_sizes, avg_drop_per_buffers, marker='o')

axs[0, 0].set_title('Avg. Number of Users vs No. of Servers')
axs[0, 1].set_title('Avg. Delay vs No. of Servers')
axs[0, 2].set_title('Dropped Packets vs No. of Servers')

axs[1, 0].set_title('Avg. Number of Users vs Buffer Size')
axs[1, 1].set_title('Avg. Delay vs Buffer Size')
axs[1, 2].set_title('Dropped Packets vs Buffer Size')

fig.tight_layout()
plt.show()