Design an Elevator System.

# elevator.py, part 1: requests and directions
from __future__ import annotations

import threading
from abc import ABC, abstractmethod
from collections.abc import Callable
from dataclasses import dataclass
from enum import Enum


class Direction(Enum):
    UP = 1
    DOWN = -1
    IDLE = 0  # also marks a car call: "stop here, whichever way you're going"


@dataclass(frozen=True)
class HallCall:  # a person on a floor pressed UP or DOWN
    floor: int
    direction: Direction


Listener = Callable[[str, int, str], None]  # (elevator id, floor, event)

# part 2: one car and its LOOK schedule (keep going while there are stops ahead, then turn)
class Elevator:
    def __init__(self, eid: str, floor: int = 0) -> None:
        self.eid, self.floor = eid, floor
        self.direction = Direction.IDLE
        self.doors_open = False
        self.stops: dict[int, set[Direction]] = {}  # floor -> who wants it (UP, DOWN or IDLE for a car call)

    def add_stop(self, floor: int, wanted: Direction) -> None:
        self.stops.setdefault(floor, set()).add(wanted)
        if self.direction is Direction.IDLE and floor != self.floor:  # an idle car now has somewhere to go
            self.direction = Direction.UP if floor > self.floor else Direction.DOWN

    def has_call(self, call: HallCall) -> bool:
        return call.direction in self.stops.get(call.floor, set())

    def ahead(self, d: Direction) -> bool:
        return any((f - self.floor) * d.value > 0 for f in self.stops)

    def _stop_here(self) -> bool:
        wants = self.stops.get(self.floor)
        if not wants:
            return False
        if self.direction is Direction.IDLE or Direction.IDLE in wants or self.direction in wants:
            return True
        return not self.ahead(self.direction)  # opposite-way call: take it only at the end of the run

    def step(self) -> str:
        if self.doors_open:
            self.doors_open = False
            return "doors close"
        if self._stop_here():
            wants = self.stops[self.floor]
            if not self.ahead(self.direction) and self.direction not in wants:
                self.direction = next(iter(wants - {Direction.IDLE}), self.direction)  # turn for the caller
            wants -= {self.direction, Direction.IDLE}
            if not wants:
                del self.stops[self.floor]
            self.doors_open = True
            if not self.stops:
                self.direction = Direction.IDLE
            return "doors open"
        if self.direction is Direction.IDLE or not self.ahead(self.direction):
            self.direction = next((d for d in (Direction.UP, Direction.DOWN) if self.ahead(d)), Direction.IDLE)
            if self.direction is Direction.IDLE:
                return "idle"
        self.floor += self.direction.value
        return f"moving {self.direction.name.lower()}"

# part 3: which car answers a hall call is a strategy
class DispatchStrategy(ABC):
    @abstractmethod
    def choose(self, cars: list[Elevator], call: HallCall) -> Elevator: ...


class LookCostDispatch(DispatchStrategy):
    """Cost = floors the car must travel before it can pick the caller up."""

    @staticmethod
    def cost(car: Elevator, call: HallCall) -> int:
        if car.direction is Direction.IDLE:
            return abs(car.floor - call.floor)
        same_way = call.direction is car.direction
        in_front = (call.floor - car.floor) * car.direction.value >= 0
        if same_way and in_front:
            return abs(call.floor - car.floor)
        ends = [f for f in car.stops] + [car.floor]
        turn = max(ends) if car.direction is Direction.UP else min(ends)  # where this run ends
        return abs(turn - car.floor) + abs(turn - call.floor)

    def choose(self, cars: list[Elevator], call: HallCall) -> Elevator:
        return min(cars, key=lambda c: (self.cost(c, call), c.eid))

# part 4: the controller: validates buttons, dispatches, and ticks the simulation
class ElevatorController:
    def __init__(self, floors: int, cars: list[Elevator], strategy: DispatchStrategy) -> None:
        self.floors, self.cars, self.strategy = floors, cars, strategy
        self.listeners: list[Listener] = []
        self._lock = threading.Lock()  # buttons are pressed on many threads; tick() runs on one

    def _check(self, floor: int) -> None:
        if not 0 <= floor < self.floors:
            raise ValueError(f"no floor {floor}")

    def hall_call(self, floor: int, direction: Direction) -> str:
        self._check(floor)
        if (floor == 0 and direction is Direction.DOWN) or (floor == self.floors - 1 and direction is Direction.UP):
            raise ValueError("no such button")
        call = HallCall(floor, direction)
        with self._lock:
            for car in self.cars:
                if car.has_call(call):
                    return car.eid  # pressed twice: same car, nothing new
            car = self.strategy.choose(self.cars, call)
            car.add_stop(floor, direction)
            return car.eid

    def car_call(self, eid: str, floor: int) -> None:
        self._check(floor)
        with self._lock:
            next(c for c in self.cars if c.eid == eid).add_stop(floor, Direction.IDLE)

    def tick(self) -> None:
        with self._lock:
            events = [(car, car.step()) for car in self.cars]
        for car, ev in events:  # notify outside the lock
            if ev != "idle":
                for fn in self.listeners:
                    fn(car.eid, car.floor, ev)

# part 5: two cars, ten floors, a short morning
if __name__ == "__main__":
    a, b = Elevator("A", 0), Elevator("B", 9)
    ctl = ElevatorController(10, [a, b], LookCostDispatch())
    ctl.listeners.append(lambda eid, fl, ev: print(f"  {eid}@{fl}: {ev}") if ev.startswith("doors open") else None)

    print("hall 3 UP ->", ctl.hall_call(3, Direction.UP))  # A: 3 floors away, B is 6 away
    print("hall 7 DOWN ->", ctl.hall_call(7, Direction.DOWN))  # B: 2 floors away
    print("hall 3 UP again ->", ctl.hall_call(3, Direction.UP))  # still A, no duplicate stop
    for _ in range(4):
        ctl.tick()
    ctl.car_call("A", 8)  # the rider who got in at 3 presses 8
    ctl.car_call("B", 0)  # the rider who got in at 7 presses ground
    print("hall 5 UP ->", ctl.hall_call(5, Direction.UP))  # A is heading up to 8 from 3: on its way
    print("hall 2 DOWN ->", ctl.hall_call(2, Direction.DOWN))  # B is heading down to 0 from 7: on its way
    for _ in range(14):
        ctl.tick()
    print("A at", a.floor, a.direction.name, "| B at", b.floor, b.direction.name)
    try:
        ctl.hall_call(9, Direction.UP)
    except ValueError as e:
        print("rejected:", e)

hall 3 UP -> A
hall 7 DOWN -> B
hall 3 UP again -> A
  B@7: doors open
  A@3: doors open
hall 5 UP -> A
hall 2 DOWN -> B
  A@5: doors open
  B@2: doors open
  A@8: doors open
  B@0: doors open
A at 8 IDLE | B at 0 IDLE
rejected: no such button