class Simulator:
    def __init__(self):
        self.events = []  # Priority Queue
        self.current_time = 0.0
        self.event_id_gen = itertools.count()  # <--- Unique ID Generator

    def schedule(self, delay, callback, *args):
        execution_time = self.current_time + delay
        # We add next(self.event_id_gen) as a tie-breaker.
        # Structure: (Time, UniqueID, Callback, Args)
        # Python compares tuples element-by-element. If Time matches, it compares UniqueID.
        # Since UniqueID is always different, it never reaches Callback or Args.
        heapq.heappush(
            self.events, (execution_time, next(self.event_id_gen), callback, args)
        )

    def run(self, max_time=1000):
        while self.events and self.current_time < max_time:
            # Unpack the 4-element tuple (ignoring the ID)
            time, _, callback, args = heapq.heappop(self.events)
            self.current_time = time
            callback(*args)

class Port:
    def __init__(self, parent_node, port_num, buffer_size=3):
        self.parent = parent_node
        self.num = port_num
        self.connected_link = None
        self.remote_port = None

        # --- Flow Control ---
        self.max_credits = buffer_size
        self.tx_credits = 0  # Credits we have to send to remote
        self.rx_buffer = collections.deque()  # Actual packet storage

        # Stats
        self.packets_sent = 0
        self.packets_received = 0

    def connect(self, link):
        self.connected_link = link
        # Identify the other side
        if link.port_a == self:
            self.remote_port = link.port_b
        else:
            self.remote_port = link.port_a

        # Initial Credit exchange (simulate link training)
        self.tx_credits = self.remote_port.max_credits

    def can_send(self):
        return self.tx_credits > 0

    def send_packet(self, packet):
        if can_send():
            self.tx_credits -= 1
            self.packets_sent += 1
            # Schedule arrival at other side (Propagation Delay)
            # Serialization delay = size / bandwidth (ignored for simplicity now)
            arrival_time = self.connected_link.latency
            sim.schedule(arrival_time, self.remote_port.receive_packet, packet)
            return True
        # STALL! We cannot send. The link is paused.
        return False

    def receive_packet(self, packet):
        self.rx_buffer.append(packet)
        self.packets_received += 1

        # Trigger processing in the parent Node (HCA or Switch)
        self.parent.process_buffer(self)

    def return_credit(self):
        """Called when parent frees buffer space. Sends credit update back."""
        # In real IB, this is piggybacked or a Flow Control Packet.
        # Here we simulate the delay of a credit update.
        sim.schedule(0.05, self._update_remote_credit)

    def _update_remote_credit(self):
        # Directly update remote counter for simulation simplicity
        if self.remote_port:
            self.remote_port.tx_credits += 1
            # If the sender was stalled, they might want to wake up
            self.remote_port.parent.check_send_queue(self.remote_port)

class IBSwitch(IBNode):
    def __init__(self, name, num_ports=4):
        super().__init__(name)
        self.lft = {}  # Linear Forwarding Table: LID -> PortNum
        for i in range(1, num_ports + 1):
            self.add_port(i)

    def set_lft(self, lid, port_num):
        self.lft[lid] = port_num

    def process_buffer(self, ingress_port):
        if not ingress_port.rx_buffer:
            return

        packet = ingress_port.rx_buffer[0]  # Peek
        out_port_num = self.lft.get(packet.dst_lid)

        if out_port_num is None:
            ingress_port.rx_buffer.popleft()
            ingress_port.return_credit()
            return

        egress_port = self.ports[out_port_num]

        # Try to forward (Cut-Through)
        if egress_port.can_send():
            # Move packet from Ingress to Egress
            pkt = ingress_port.rx_buffer.popleft()

            # Processing Delay (Switch Logic latency)
            sim.schedule(0.05, egress_port.send_packet, pkt)

            # Free up ingress buffer (Credit Return)
            ingress_port.return_credit()
        else:
            # Head-of-Line Blocking simulated here
            pass

    def check_send_queue(self, port):
        # Triggered when credits return.
        # A real switch would check internal crossbar queues.
        # Simplification: We rely on the receive event loop for retry logic in this basic sim
        pass

class SubnetManager:
    def discover_and_configure(self, nodes):
        print("--- SM: Starting Discovery ---")
        
        # 1. Assign LIDs to Hosts
        for i, node in enumerate(nodes):
            node.lid = i + 1
            print(f"SM: Assigned LID {node.lid} to {node.name}")

        # 2. Program Switch Routes (BFS Algorithm)
        # (Simplified routing logic omitted for brevity - full code on github)