
'''simple docstring'''
from collections import deque






class    UpperCAmelCase_				:





	def __init__(    self ,       lowercase_ ,       lowercase_ ,       lowercase_):
					snake_case_ :    List[str]     			=						process_name  # process name
					snake_case_ :    Union[str, Any]     			=						arrival_time  # arrival time of the process
					# completion time of finished process or last interrupted time
					snake_case_ :    Any     			=						arrival_time
					snake_case_ :    int     			=						burst_time  # remaining burst time
					snake_case_ :    str     			=						0  # total time of the process wait in ready queue
					snake_case_ :    Dict     			=						0  # time from arrival time to completion time






class    UpperCAmelCase_				:





	def __init__(    self ,       lowercase_ ,       lowercase_ ,       lowercase_ ,       lowercase_ ,       ):
					# total number of mlfq's queues
					snake_case_ :    Tuple     			=						number_of_queues
					# time slice of queues that round robin algorithm applied
					snake_case_ :    Dict     			=						time_slices
					# unfinished process is in this ready_queue
					snake_case_ :    int     			=						queue
					# current time
					snake_case_ :    Tuple     			=						current_time
					# finished process is in this sequence queue
					snake_case_ :    Optional[Any]     			=						deque()





	def        snake_case__		(    self):
					snake_case_ :    Any     			=						[]
					for i in range(len(self.finish_queue)):
									sequence.append(self.finish_queue[i].process_name)
					return sequence





	def        snake_case__		(    self ,       lowercase_):
					snake_case_ :    Union[str, Any]     			=						[]
					for i in range(len(_A)):
									waiting_times.append(queue[i].waiting_time)
					return waiting_times





	def        snake_case__		(    self ,       lowercase_):
					snake_case_ :    Dict     			=						[]
					for i in range(len(_A)):
									turnaround_times.append(queue[i].turnaround_time)
					return turnaround_times





	def        snake_case__		(    self ,       lowercase_):
					snake_case_ :    Any     			=						[]
					for i in range(len(_A)):
									completion_times.append(queue[i].stop_time)
					return completion_times





	def        snake_case__		(    self ,       lowercase_):
					return [q.burst_time for q in queue]





	def        snake_case__		(    self ,       lowercase_):
					process.waiting_time += self.current_time - process.stop_time
					return process.waiting_time





	def        snake_case__		(    self ,       lowercase_):
					snake_case_ :    Optional[int]     			=						deque()  # sequence deque of finished process
					while len(_A) != 0:
									snake_case_ :    List[Any]     			=						ready_queue.popleft()  # current process

									# if process's arrival time is later than current time, update current time
									if self.current_time < cp.arrival_time:
													self.current_time += cp.arrival_time

									# update waiting time of current process
									self.update_waiting_time(_A)
									# update current time
									self.current_time += cp.burst_time
									# finish the process and set the process's burst-time 0
									snake_case_ :    List[str]     			=						0
									# set the process's turnaround time because it is finished
									snake_case_ :    List[Any]     			=						self.current_time - cp.arrival_time
									# set the completion time
									snake_case_ :    Any     			=						self.current_time
									# add the process to queue that has finished queue
									finished.append(_A)

					self.finish_queue.extend(_A)  # add finished process to finish queue
					# FCFS will finish all remaining processes
					return finished





	def        snake_case__		(    self ,       lowercase_ ,       lowercase_):
					snake_case_ :    Tuple     			=						deque()  # sequence deque of terminated process
					# just for 1 cycle and unfinished processes will go back to queue
					for _ in range(len(_A)):
									snake_case_ :    Any     			=						ready_queue.popleft()  # current process

									# if process's arrival time is later than current time, update current time
									if self.current_time < cp.arrival_time:
													self.current_time += cp.arrival_time

									# update waiting time of unfinished processes
									self.update_waiting_time(_A)
									# if the burst time of process is bigger than time-slice
									if cp.burst_time > time_slice:
													# use CPU for only time-slice
													self.current_time += time_slice
													# update remaining burst time
													cp.burst_time -= time_slice
													# update end point time
													snake_case_ :    Dict     			=						self.current_time
													# locate the process behind the queue because it is not finished
													ready_queue.append(_A)
									else:
													# use CPU for remaining burst time
													self.current_time += cp.burst_time
													# set burst time 0 because the process is finished
													snake_case_ :    int     			=						0
													# set the finish time
													snake_case_ :    Optional[Any]     			=						self.current_time
													# update the process' turnaround time because it is finished
													snake_case_ :    Union[str, Any]     			=						self.current_time - cp.arrival_time
													# add the process to queue that has finished queue
													finished.append(_A)

					self.finish_queue.extend(_A)  # add finished process to finish queue
					# return finished processes queue and remaining processes queue
					return finished, ready_queue





	def        snake_case__		(    self):

					#  all queues except last one have round_robin algorithm
					for i in range(self.number_of_queues - 1):
									snake_case_			, snake_case_ :    Dict     			=						self.round_robin(
									    self.ready_queue ,       self.time_slices[i])
					#  the last queue has first_come_first_served algorithm
					self.first_come_first_served(self.ready_queue)

					return self.finish_queue


if __name__ == "__main__":
		import doctest

		a_											=						Process("P1", 0, 53)
		a_											=						Process("P2", 0, 17)
		a_											=						Process("P3", 0, 68)
		a_											=						Process("P4", 0, 24)
		a_											=						3
		a_											=						[17, 25]
		a_											=						deque([Pa, Pa, Pa, Pa])

		if len(time_slices) != number_of_queues - 1:
				raise SystemExit(0)

		doctest.testmod(extraglobs={"queue": deque([Pa, Pa, Pa, Pa])})

		a_											=						Process("P1", 0, 53)
		a_											=						Process("P2", 0, 17)
		a_											=						Process("P3", 0, 68)
		a_											=						Process("P4", 0, 24)
		a_											=						3
		a_											=						[17, 25]
		a_											=						deque([Pa, Pa, Pa, Pa])
		a_											=						MLFQ(number_of_queues, time_slices, queue, 0)
		a_											=						mlfq.multi_level_feedback_queue()

		# print total waiting times of processes(P1, P2, P3, P4)
		print(
		    f"""waiting time:\
        \t\t\t{MLFQ.calculate_waiting_time(mlfq, [Pa, Pa, Pa, Pa])}"""
		)
		# print completion times of processes(P1, P2, P3, P4)
		print(
		    f"""completion time:\
        \t\t{MLFQ.calculate_completion_time(mlfq, [Pa, Pa, Pa, Pa])}"""
		)
		# print total turnaround times of processes(P1, P2, P3, P4)
		print(
		    f"""turnaround time:\
        \t\t{MLFQ.calculate_turnaround_time(mlfq, [Pa, Pa, Pa, Pa])}"""
		)
		# print sequence of finished processes
		print(
		    f"""sequence of finished processes:\
        {mlfq.calculate_sequence_of_finish_queue()}"""
		)






'''simple docstring'''
from __future__ import annotations

from statistics import mean

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_ :    Any     			=						[0] * no_of_processes
    snake_case_ :    Optional[int]     			=						[0] * no_of_processes

    # Initialize remaining_time to waiting_time.

    for i in range(__SCREAMING_SNAKE_CASE       ):
        snake_case_ :    str     			=						burst_time[i]
    snake_case_ :    list[int]     			=						[]

    snake_case_ :    Tuple     			=						0
    snake_case_ :    Optional[int]     			=						0

    # When processes are not completed,
    # A process whose arrival time has passed \
    # and has remaining execution time is put into the ready_process.
    # The shortest process in the ready_process, target_process is executed.

    while completed != no_of_processes:
        snake_case_ :    Any     			=						[]
        snake_case_ :    Dict     			=						-1

        for i in range(__SCREAMING_SNAKE_CASE       ):
            if (arrival_time[i] <= total_time) and (remaining_time[i] > 0):
                ready_process.append(__SCREAMING_SNAKE_CASE       )

        if len(__SCREAMING_SNAKE_CASE       ) > 0:
            snake_case_ :    Dict     			=						ready_process[0]
            for i in ready_process:
                if remaining_time[i] < remaining_time[target_process]:
                    snake_case_ :    Optional[int]     			=						i
            total_time += burst_time[target_process]
            completed += 1
            snake_case_ :    Tuple     			=						0
            snake_case_ :    int     			=						(
                total_time - arrival_time[target_process] - burst_time[target_process]
            )
        else:
            total_time += 1

    return waiting_time

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_ :    Optional[int]     			=						[0] * no_of_processes
    for i in range(__SCREAMING_SNAKE_CASE       ):
        snake_case_ :    Dict     			=						burst_time[i] + waiting_time[i]
    return turn_around_time


if __name__ == "__main__":
  print("[TEST CASE 01]")

  a_											=						4
  a_											=						[2, 5, 3, 7]
  a_											=						[0, 0, 0, 0]
  a_											=						calculate_waitingtime(arrival_time, burst_time, no_of_processes)
  a_											=						calculate_turnaroundtime(
      burst_time, no_of_processes, waiting_time
  )

  # Printing the Result
  print("PID\tBurst Time\tArrival Time\tWaiting Time\tTurnaround Time")
  for i, process_id in enumerate(list(range(1, 5))):
    print(
        f"""{process_id}\t{burst_time[i]}\t\t\t{arrival_time[i]}\t\t\t\t"""
        f"""{waiting_time[i]}\t\t\t\t{turn_around_time[i]}"""
    )
  print(f"""\nAverage waiting time = {mean(waiting_time):.5f}""")
  print(f"""Average turnaround time = {mean(turn_around_time):.5f}""")




