Elevator System

export {};
 
enum Direction {
  Up = "up",
  Down = "down",
  Idle = "idle",
}
 
interface HallCall {
  readonly id: string;
  readonly floor: number;
  readonly direction: Direction.Up | Direction.Down;
}
 
interface CarReport {
  readonly carId: string;
  readonly floor: number;
  readonly direction: Direction;
  readonly state: string;
  readonly pendingStops: readonly number[];
}
 
type CarStepKind =
  | "idle"
  | "moved"
  | "doors-open"
  | "doors-closed";
 
interface CarStep {
  readonly carId: string;
  readonly floor: number;
  readonly state: string;
  readonly kind: CarStepKind;
}
 
class StopQueue {
  private readonly stops = new Set<number>();
 
  public add(floor: number): void {
    this.stops.add(floor);
  }
 
  public take(floor: number): boolean {
    return this.stops.delete(floor);
  }
 
  public hasAbove(floor: number): boolean {
    return [...this.stops].some((stop) => stop > floor);
  }
 
  public hasBelow(floor: number): boolean {
    return [...this.stops].some((stop) => stop < floor);
  }
 
  public ascending(): readonly number[] {
    return [...this.stops].sort((a, b) => a - b);
  }
 
  public directionToNearest(floor: number): Direction {
    const ordered = this.ascending();
    const first = ordered[0];
    if (first === undefined) return Direction.Idle;
 
    let nearest = first;
    for (const candidate of ordered.slice(1)) {
      const candidateDistance = Math.abs(candidate - floor);
      const nearestDistance = Math.abs(nearest - floor);
      if (
        candidateDistance < nearestDistance ||
        (candidateDistance === nearestDistance && candidate < nearest)
      ) {
        nearest = candidate;
      }
    }
 
    if (nearest > floor) return Direction.Up;
    if (nearest < floor) return Direction.Down;
    return Direction.Idle;
  }
}
 
interface ElevatorState {
  readonly name: string;
  readonly direction: Direction;
  step(car: ElevatorCar): CarStep;
}
 
class ElevatorCar {
  private currentFloor: number;
  private readonly stops = new StopQueue();
  private state: ElevatorState;
 
  public constructor(
    public readonly id: string,
    public readonly floorCount: number,
    initialFloor: number,
  ) {
    if (id.trim().length === 0) {
      throw new Error("car id is required");
    }
    if (!Number.isInteger(floorCount) || floorCount < 2) {
      throw new Error("a building needs at least two floors");
    }
    if (
      !Number.isInteger(initialFloor) ||
      initialFloor < 0 ||
      initialFloor >= floorCount
    ) {
      throw new Error("initial car floor is out of range");
    }
 
    this.currentFloor = initialFloor;
    this.state = new IdleState();
  }
 
  public get floor(): number {
    return this.currentFloor;
  }
 
  public get direction(): Direction {
    return this.state.direction;
  }
 
  public addStop(floor: number): void {
    this.requireFloor(floor);
    this.stops.add(floor);
  }
 
  public step(): CarStep {
    return this.state.step(this);
  }
 
  public report(): CarReport {
    return {
      carId: this.id,
      floor: this.currentFloor,
      direction: this.state.direction,
      state: this.state.name,
      pendingStops: this.stops.ascending(),
    };
  }
 
  public transitionTo(state: ElevatorState): void {
    this.state = state;
  }
 
  public takeStopHere(): boolean {
    return this.stops.take(this.currentFloor);
  }
 
  public hasStopAbove(): boolean {
    return this.stops.hasAbove(this.currentFloor);
  }
 
  public hasStopBelow(): boolean {
    return this.stops.hasBelow(this.currentFloor);
  }
 
  public directionToNearestStop(): Direction {
    return this.stops.directionToNearest(this.currentFloor);
  }
 
  public directionAfter(preferred: Direction): Direction {
    if (preferred === Direction.Up && this.hasStopAbove()) {
      return Direction.Up;
    }
    if (preferred === Direction.Down && this.hasStopBelow()) {
      return Direction.Down;
    }
    if (preferred === Direction.Up && this.hasStopBelow()) {
      return Direction.Down;
    }
    if (preferred === Direction.Down && this.hasStopAbove()) {
      return Direction.Up;
    }
    return this.directionToNearestStop();
  }
 
  public moveOneFloor(direction: Direction.Up | Direction.Down): void {
    const nextFloor =
      this.currentFloor + (direction === Direction.Up ? 1 : -1);
    this.requireFloor(nextFloor);
    this.currentFloor = nextFloor;
  }
 
  public event(kind: CarStepKind): CarStep {
    return {
      carId: this.id,
      floor: this.currentFloor,
      state: this.state.name,
      kind,
    };
  }
 
  private requireFloor(floor: number): void {
    if (
      !Number.isInteger(floor) ||
      floor < 0 ||
      floor >= this.floorCount
    ) {
      throw new Error(`floor ${floor} is out of range for car ${this.id}`);
    }
  }
}
 
class IdleState implements ElevatorState {
  public readonly name = "idle";
  public readonly direction = Direction.Idle;
 
  public step(car: ElevatorCar): CarStep {
    if (car.takeStopHere()) {
      car.transitionTo(new DoorsOpenState(Direction.Idle));
      return car.event("doors-open");
    }
 
    const direction = car.directionToNearestStop();
    if (direction === Direction.Idle) return car.event("idle");
 
    const nextState =
      direction === Direction.Up
        ? new MovingUpState()
        : new MovingDownState();
    car.transitionTo(nextState);
    return nextState.step(car);
  }
}
 
class MovingUpState implements ElevatorState {
  public readonly name = "moving-up";
  public readonly direction = Direction.Up;
 
  public step(car: ElevatorCar): CarStep {
    if (car.takeStopHere()) {
      car.transitionTo(new DoorsOpenState(Direction.Up));
      return car.event("doors-open");
    }
 
    if (!car.hasStopAbove()) {
      if (car.hasStopBelow()) {
        const nextState = new MovingDownState();
        car.transitionTo(nextState);
        return nextState.step(car);
      }
      car.transitionTo(new IdleState());
      return car.event("idle");
    }
 
    car.moveOneFloor(Direction.Up);
    if (car.takeStopHere()) {
      car.transitionTo(new DoorsOpenState(Direction.Up));
      return car.event("doors-open");
    }
    return car.event("moved");
  }
}
 
class MovingDownState implements ElevatorState {
  public readonly name = "moving-down";
  public readonly direction = Direction.Down;
 
  public step(car: ElevatorCar): CarStep {
    if (car.takeStopHere()) {
      car.transitionTo(new DoorsOpenState(Direction.Down));
      return car.event("doors-open");
    }
 
    if (!car.hasStopBelow()) {
      if (car.hasStopAbove()) {
        const nextState = new MovingUpState();
        car.transitionTo(nextState);
        return nextState.step(car);
      }
      car.transitionTo(new IdleState());
      return car.event("idle");
    }
 
    car.moveOneFloor(Direction.Down);
    if (car.takeStopHere()) {
      car.transitionTo(new DoorsOpenState(Direction.Down));
      return car.event("doors-open");
    }
    return car.event("moved");
  }
}
 
class DoorsOpenState implements ElevatorState {
  public readonly name = "doors-open";
 
  public constructor(
    public readonly direction: Direction,
  ) {}
 
  public step(car: ElevatorCar): CarStep {
    const nextDirection = car.directionAfter(this.direction);
 
    if (nextDirection === Direction.Up) {
      car.transitionTo(new MovingUpState());
    } else if (nextDirection === Direction.Down) {
      car.transitionTo(new MovingDownState());
    } else {
      car.transitionTo(new IdleState());
    }
 
    return car.event("doors-closed");
  }
}
 
interface DispatchStrategy {
  selectCar(
    call: HallCall,
    cars: readonly ElevatorCar[],
  ): ElevatorCar;
}
 
class NearestSuitableCarStrategy implements DispatchStrategy {
  public selectCar(
    call: HallCall,
    cars: readonly ElevatorCar[],
  ): ElevatorCar {
    if (cars.length === 0) {
      throw new Error("no elevator cars are available");
    }
 
    const ranked = [...cars].sort((a, b) => {
      const aScore = this.score(call, a);
      const bScore = this.score(call, b);
      return (
        aScore.suitability - bScore.suitability ||
        aScore.distance - bScore.distance ||
        a.id.localeCompare(b.id)
      );
    });
    const selected = ranked[0];
    if (selected === undefined) {
      throw new Error("dispatch could not select a car");
    }
    return selected;
  }
 
  private score(
    call: HallCall,
    car: ElevatorCar,
  ): { suitability: number; distance: number } {
    const idle = car.direction === Direction.Idle;
    const movingTowardCall =
      (car.direction === Direction.Up &&
        call.direction === Direction.Up &&
        car.floor <= call.floor) ||
      (car.direction === Direction.Down &&
        call.direction === Direction.Down &&
        car.floor >= call.floor);
 
    return {
      suitability: idle || movingTowardCall ? 0 : 1,
      distance: Math.abs(car.floor - call.floor),
    };
  }
}
 
interface HallAssignment {
  readonly call: HallCall;
  readonly carId: string;
}
 
class ElevatorSystem {
  private readonly cars: readonly ElevatorCar[];
  private callSequence = 0;
 
  public constructor(
    private readonly floorCount: number,
    cars: readonly ElevatorCar[],
    private readonly dispatch: DispatchStrategy,
  ) {
    if (!Number.isInteger(floorCount) || floorCount < 2) {
      throw new Error("a building needs at least two floors");
    }
    if (cars.length === 0) {
      throw new Error("at least one elevator car is required");
    }
 
    const ids = new Set<string>();
    for (const car of cars) {
      if (ids.has(car.id)) {
        throw new Error(`duplicate elevator car ${car.id}`);
      }
      if (car.floorCount !== floorCount) {
        throw new Error(`car ${car.id} serves a different floor range`);
      }
      ids.add(car.id);
    }
 
    this.cars = [...cars].sort((a, b) => a.id.localeCompare(b.id));
  }
 
  public hallCall(
    floor: number,
    direction: Direction.Up | Direction.Down,
  ): HallAssignment {
    this.requireFloor(floor);
    if (floor === 0 && direction === Direction.Down) {
      throw new Error("the ground floor has no down hall call");
    }
    if (
      floor === this.floorCount - 1 &&
      direction === Direction.Up
    ) {
      throw new Error("the top floor has no up hall call");
    }
 
    const call: HallCall = {
      id: `H-${++this.callSequence}`,
      floor,
      direction,
    };
    const car = this.dispatch.selectCar(call, this.cars);
    car.addStop(floor);
    return { call, carId: car.id };
  }
 
  public requestFloor(carId: string, floor: number): void {
    this.requireFloor(floor);
    const car = this.cars.find((candidate) => candidate.id === carId);
    if (car === undefined) {
      throw new Error(`unknown elevator car ${carId}`);
    }
    car.addStop(floor);
  }
 
  public step(): readonly CarStep[] {
    return this.cars.map((car) => car.step());
  }
 
  public reports(): readonly CarReport[] {
    return this.cars.map((car) => car.report());
  }
 
  private requireFloor(floor: number): void {
    if (
      !Number.isInteger(floor) ||
      floor < 0 ||
      floor >= this.floorCount
    ) {
      throw new Error(`floor ${floor} is outside the building`);
    }
  }
}
 
const system = new ElevatorSystem(
  10,
  [
    new ElevatorCar("A", 10, 0),
    new ElevatorCar("B", 10, 9),
  ],
  new NearestSuitableCarStrategy(),
);
 
const first = system.hallCall(4, Direction.Up);
const second = system.hallCall(7, Direction.Down);
 
console.log(
  `${first.call.id}: car ${first.carId} for floor ${first.call.floor} ${first.call.direction}`,
);
console.log(
  `${second.call.id}: car ${second.carId} for floor ${second.call.floor} ${second.call.direction}`,
);
 
for (let tick = 1; tick <= 2; tick += 1) {
  const events = system.step();
  const status = system.reports()
    .map((car) => `${car.carId}@${car.floor} ${car.state}`)
    .join(" | ");
  console.log(`Tick ${tick}: ${status}`);
 
  const arrival = events.find((event) => event.kind === "doors-open");
  if (arrival !== undefined) {
    console.log(
      `Arrival: car ${arrival.carId} opened at floor ${arrival.floor}`,
    );
  }
}