Facade

// ---- The subsystems: each does one job and knows nothing about rentals as a whole. ----
class Accounts {
  private readonly suspended = new Set(["zoe"]);
  canRide(rider: string): boolean { return !this.suspended.has(rider); }
}

class Payments {
  readonly holds = new Map<string, number>();
  hold(rider: string, pence: number): void { this.holds.set(rider, pence); }
  release(rider: string): void { this.holds.delete(rider); }
}

class Docks {
  readonly bikes: Record<string, string[]> = { D7: ["E-205"], D9: ["B-17"] };
  reserve(dock: string): string { return this.bikes[dock].pop()!; }
  putBack(dock: string, bike: string): void { this.bikes[dock].push(bike); }
}

class Locks {
  open(dock: string): boolean { return dock !== "D9"; }   // D9's lock is jammed today
}

class Rides {
  private count = 0;
  start(rider: string, bike: string): string { void rider; void bike; return `RD-${++this.count}`; }
}

class Notifier {
  push(rider: string, text: string): void { void rider; void text; }   // would send a phone notification
}

// ---- The facade: one call for the common job, in the right order, with the clean-up done right. ----
class RentalDesk {
  constructor(private readonly accounts: Accounts, private readonly payments: Payments, private readonly docks: Docks,
              private readonly locks: Locks, private readonly rides: Rides, private readonly notifier: Notifier) {}

  startRental(rider: string, dock: string): string {
    const steps: string[] = [];
    if (!this.accounts.canRide(rider)) return "account suspended: rental refused";
    steps.push("account ok");
    this.payments.hold(rider, 100);
    steps.push("hold 100p");
    const bike = this.docks.reserve(dock);
    steps.push(`bike ${bike} reserved`);
    if (!this.locks.open(dock)) {   // undo the earlier steps in reverse
      this.docks.putBack(dock, bike);
      this.payments.release(rider);
      steps.push("lock jammed -> bike put back, hold released: rental refused");
      return steps.join(" -> ");
    }
    steps.push("lock opened");
    const ride = this.rides.start(rider, bike);
    steps.push(`ride ${ride} started`);
    this.notifier.push(rider, `Ride ${ride} started`);
    steps.push("push sent");
    return steps.join(" -> ");
  }
}

const payments = new Payments(), docks = new Docks();
const desk = new RentalDesk(new Accounts(), payments, docks, new Locks(), new Rides(), new Notifier());
for (const [rider, dock] of [["mia", "D7"], ["leo", "D9"], ["zoe", "D7"]]) console.log(`start_rental(${rider}, ${dock}): ${desk.startRental(rider, dock)}`);
const held = [...payments.holds].map(([r, p]) => `${r} ${p}p`).join(", ");
console.log(`card holds still open: ${held} | bikes back at D9: ${docks.bikes.D9.join(", ")}`);

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Main {
    // ---- The subsystems: each does one job and knows nothing about rentals as a whole. ----
    static class Accounts {
        private final Set<String> suspended = new HashSet<>(Set.of("zoe"));
        boolean canRide(String rider) { return !suspended.contains(rider); }
    }

    static class Payments {
        final Map<String, Integer> holds = new HashMap<>();
        void hold(String rider, int pence) { holds.put(rider, pence); }
        void release(String rider) { holds.remove(rider); }
    }

    static class Docks {
        final Map<String, List<String>> bikes = new HashMap<>(Map.of("D7", new ArrayList<>(List.of("E-205")), "D9", new ArrayList<>(List.of("B-17"))));
        String reserve(String dock) { List<String> b = bikes.get(dock); return b.remove(b.size() - 1); }
        void putBack(String dock, String bike) { bikes.get(dock).add(bike); }
    }

    static class Locks {
        boolean open(String dock) { return !dock.equals("D9"); }   // D9's lock is jammed today
    }

    static class Rides {
        private int count;
        String start(String rider, String bike) { return "RD-" + (++count); }
    }

    static class Notifier {
        void push(String rider, String text) { }   // would send a phone notification
    }

    // ---- The facade: one call for the common job, in the right order, with the clean-up done right. ----
    static class RentalDesk {
        private final Accounts accounts; private final Payments payments; private final Docks docks;
        private final Locks locks; private final Rides rides; private final Notifier notifier;

        RentalDesk(Accounts accounts, Payments payments, Docks docks, Locks locks, Rides rides, Notifier notifier) {
            this.accounts = accounts; this.payments = payments; this.docks = docks; this.locks = locks; this.rides = rides; this.notifier = notifier;
        }

        String startRental(String rider, String dock) {
            List<String> steps = new ArrayList<>();
            if (!accounts.canRide(rider)) return "account suspended: rental refused";
            steps.add("account ok");
            payments.hold(rider, 100);
            steps.add("hold 100p");
            String bike = docks.reserve(dock);
            steps.add("bike " + bike + " reserved");
            if (!locks.open(dock)) {   // undo the earlier steps in reverse
                docks.putBack(dock, bike);
                payments.release(rider);
                steps.add("lock jammed -> bike put back, hold released: rental refused");
                return String.join(" -> ", steps);
            }
            steps.add("lock opened");
            String ride = rides.start(rider, bike);
            steps.add("ride " + ride + " started");
            notifier.push(rider, "Ride " + ride + " started");
            steps.add("push sent");
            return String.join(" -> ", steps);
        }
    }

    public static void main(String[] args) {
        Payments payments = new Payments();
        Docks docks = new Docks();
        RentalDesk desk = new RentalDesk(new Accounts(), payments, docks, new Locks(), new Rides(), new Notifier());
        String[][] asks = {{"mia", "D7"}, {"leo", "D9"}, {"zoe", "D7"}};
        for (String[] a : asks) System.out.println("start_rental(" + a[0] + ", " + a[1] + "): " + desk.startRental(a[0], a[1]));
        List<String> held = new ArrayList<>();
        payments.holds.forEach((r, p) -> held.add(r + " " + p + "p"));
        System.out.println("card holds still open: " + String.join(", ", held) + " | bikes back at D9: " + String.join(", ", docks.bikes.get("D9")));
    }
}