import math
import random

# Ограничение длины очереди
Q_LIMIT = 100
# Состояния устройства
BUSY = 1
IDLE = 0

# Переменные
next_event_type = 0
num_custs_delayed = 0
num_events = 3  # Исправлено с 2 на 3
num_in_q = 0
server_status = IDLE

area_num_in_q = 0.0
area_server_status = 0.0
mean_interarrival = 0.0
mean_service = 0.0
sim_time = 0.0
time_arrival = [0.0] * (Q_LIMIT + 2)  # Увеличен размер для предотвращения ошибки индексации
time_end = 480.0
time_last_event = 0.0
time_next_event = [0.0, 0.0, 0.0, 0.0]
total_of_delays = 0.0

# Чтение и запись файлов
outfile = open("mml.out", "w")


def initialize():
    global sim_time, server_status, num_in_q, time_last_event
    global num_custs_delayed, total_of_delays, area_num_in_q, area_server_status
    global time_next_event

    sim_time = 0.0
    server_status = IDLE
    num_in_q = 0
    time_last_event = 0.0

    num_custs_delayed = 0
    total_of_delays = 0.0
    area_num_in_q = 0.0
    area_server_status = 0.0

    # Инициализируем список событий
    time_next_event[1] = sim_time + expon(mean_interarrival)
    time_next_event[2] = float('inf')  # Завершение обслуживания изначально отменено
    time_next_event[3] = time_end  # Планируем событие отчета


def timing():
    global next_event_type, sim_time

    min_time_next_event = float('inf')
    next_event_type = 0

    # Определяем тип следующего события
    for i in range(1, num_events + 1):
        if time_next_event[i] < min_time_next_event:
            min_time_next_event = time_next_event[i]
            next_event_type = i

    # Проверяем, является ли список событий пустым
    if next_event_type == 0:
        outfile.write(f"\nСписок событий пуст в момент времени {sim_time}\n")
        exit(1)

    sim_time = min_time_next_event


def arrive():
    global num_in_q, num_custs_delayed, server_status, total_of_delays

    time_next_event[1] = sim_time + expon(mean_interarrival)

    if server_status == BUSY:
        num_in_q += 1

        if num_in_q > Q_LIMIT:
            outfile.write(f"\nПереполнение очереди в момент времени {sim_time}\n")
            exit(2)

        time_arrival[num_in_q] = sim_time
    else:
        delay = 0.0
        total_of_delays += delay
        num_custs_delayed += 1
        server_status = BUSY
        time_next_event[2] = sim_time + expon(mean_service)


def depart():
    global num_in_q, num_custs_delayed, total_of_delays

    if num_in_q == 0:
        server_status = IDLE
        time_next_event[2] = float('inf')
    else:
        num_in_q -= 1
        delay = sim_time - time_arrival[1]
        total_of_delays += delay
        num_custs_delayed += 1
        time_next_event[2] = sim_time + expon(mean_service)

        # Сдвигаем очередь вперед
        for i in range(1, num_in_q + 1):
            time_arrival[i] = time_arrival[i + 1]


def report():
    average_delay = total_of_delays / num_custs_delayed if num_custs_delayed > 0 else 0.0
    average_q = area_num_in_q / sim_time if sim_time > 0 else 0.0
    utilization = area_server_status / sim_time if sim_time > 0 else 0.0

    outfile.write(f"\n\nСредняя задержка в очереди: {average_delay:.3f} минут\n")
    outfile.write(f"Среднее число требований в очереди: {average_q:.3f}\n")
    outfile.write(f"Коэффициент занятости устройства: {utilization:.3f}\n")
    outfile.write(f"Число завершённых задержек: {num_custs_delayed}\n")


def update_time_avg_status():
    global area_num_in_q, area_server_status, time_last_event

    time_since_last_event = sim_time - time_last_event
    time_last_event = sim_time

    area_num_in_q += num_in_q * time_since_last_event
    area_server_status += server_status * time_since_last_event


def expon(mean):
    return -mean * math.log(random.random())


def main():
    global mean_interarrival, mean_service, num_delays_required

    # Считываем входные параметры
    # В оригинальном коде параметры считываются из файла "mml.in"
    # Здесь мы задаём их вручную для простоты
    mean_interarrival = 1.0  # Среднее время между поступлениями
    mean_service = 0.5       # Среднее время обслуживания
    num_delays_required = 480  # Число задержек требований

    # Пишем заголовок отчета
    outfile.write(f"Среднее время между поступлениями: {mean_interarrival:.3f} мин\n")
    outfile.write(f"Среднее время обслуживания: {mean_service:.3f} мин\n")
    outfile.write(f"Число требований: {num_delays_required}\n")

    # Инициализируем моделирование
    initialize()

    # Выполняем цикл моделирования
    while True:
        timing()
        update_time_avg_status()

        if next_event_type == 1:
            arrive()
        elif next_event_type == 2:
            depart()
        elif next_event_type == 3:
            report()
            break  # Завершаем моделирование после отчета

    # Закрываем файл отчета
    outfile.close()


# Запуск программы
if __name__ == "__main__":
    main()