Movie ticket booking

const HOLD_SECONDS = 300;

interface Hold { id: string; user: string; seats: string[]; expiresAt: number; confirmed: boolean; }

class Show {
  readonly owner = new Map<string, Hold>(); // seat -> the hold or booking that has it
  constructor(readonly id: string, readonly seats: string[]) {}
  taken(seat: string, now: number): boolean {
    const h = this.owner.get(seat);
    return h !== undefined && (h.confirmed || h.expiresAt > now); // an expired hold counts as free
  }
}

// JavaScript runs one callback at a time, so the check-then-set in hold() can't be interleaved within one
// process. With several servers, the same all-or-nothing rule must move into the database (a transaction).
class BookingService {
  private shows = new Map<string, Show>();
  private holds = new Map<string, { show: Show; hold: Hold }>();
  private nextId = 1;

  addShow(show: Show): void { this.shows.set(show.id, show); }

  /** All or nothing: either every seat is held for this user, or none is. */
  hold(showId: string, seats: string[], user: string, now: number): string | null {
    const show = this.shows.get(showId)!;
    if (seats.some((s) => !show.seats.includes(s) || show.taken(s, now))) return null;
    const h: Hold = { id: `H${this.nextId++}`, user, seats: [...seats], expiresAt: now + HOLD_SECONDS, confirmed: false };
    for (const s of seats) show.owner.set(s, h);
    this.holds.set(h.id, { show, hold: h });
    return h.id;
  }

  /** Called after payment succeeds. Fails if the hold expired first. */
  confirm(holdId: string, now: number): boolean {
    const { show, hold: h } = this.holds.get(holdId)!;
    if (h.confirmed) return true;
    if (h.expiresAt <= now || h.seats.some((s) => show.owner.get(s) !== h)) return false;
    h.confirmed = true;
    return true;
  }

  seatMap(showId: string, now: number): string {
    const show = this.shows.get(showId)!;
    return show.seats.map((s) => {
      const h = show.owner.get(s);
      if (!h || !show.taken(s, now)) return `${s}:free`;
      return `${s}:${h.confirmed ? "booked" : "held"}(${h.user})`;
    }).join(" ");
  }
}

async function main(): Promise<void> {
  const svc = new BookingService();
  svc.addShow(new Show("S1", ["A1", "A2", "A3", "A4"]));
  const h1 = svc.hold("S1", ["A1", "A2"], "ana", 0)!;
  console.log("ana holds A1 A2:", h1);
  console.log("ben holds A2 A3:", svc.hold("S1", ["A2", "A3"], "ben", 10) ?? "None");
  const h2 = svc.hold("S1", ["A3", "A4"], "ben", 10)!;
  console.log("ben holds A3 A4:", h2);
  console.log("ana confirms at 100 s:", svc.confirm(h1, 100) ? "True" : "False");
  console.log("ben confirms at 400 s:", svc.confirm(h2, 400) ? "True" : "False");
  console.log("cara holds A3 at 401 s:", svc.hold("S1", ["A3"], "cara", 401) ?? "None");
  console.log(svc.seatMap("S1", 401));
  const results = await Promise.all(Array.from({ length: 8 }, async (_, i) => svc.hold("S1", ["A4"], `u${i}`, 500)));
  console.log("8 buyers race for A4 at 500 s, holds granted:", results.filter((r) => r !== null).length);
}
void main();

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

class Hold {
    final String id, user;
    final List<String> seats;
    final long expiresAt;
    boolean confirmed;

    Hold(String id, String user, List<String> seats, long expiresAt) {
        this.id = id;
        this.user = user;
        this.seats = List.copyOf(seats);
        this.expiresAt = expiresAt;
    }
}

class Show {
    final String id;
    final List<String> seats;
    final Map<String, Hold> owner = new ConcurrentHashMap<>(); // seat -> the hold or booking that has it

    Show(String id, List<String> seats) {
        this.id = id;
        this.seats = seats;
    }

    boolean taken(String seat, long now) {
        Hold h = owner.get(seat);
        return h != null && (h.confirmed || h.expiresAt > now); // an expired hold counts as free
    }
}

class BookingService {
    static final long HOLD_SECONDS = 300;
    private record Entry(Show show, Hold hold) {}

    private final Map<String, Show> shows = new ConcurrentHashMap<>();
    private final Map<String, Entry> holds = new ConcurrentHashMap<>();
    private final AtomicInteger ids = new AtomicInteger();

    void addShow(Show s) {
        shows.put(s.id, s);
    }

    /** All or nothing: either every seat is held for this user, or none is. Locks only this show. */
    String hold(String showId, List<String> seats, String user, long now) {
        Show show = shows.get(showId);
        synchronized (show) {
            for (String s : seats) if (!show.seats.contains(s) || show.taken(s, now)) return null;
            Hold h = new Hold("H" + ids.incrementAndGet(), user, seats, now + HOLD_SECONDS);
            for (String s : seats) show.owner.put(s, h);
            holds.put(h.id, new Entry(show, h));
            return h.id;
        }
    }

    /** Called after payment succeeds. Fails if the hold expired first. */
    boolean confirm(String holdId, long now) {
        Entry e = holds.get(holdId);
        synchronized (e.show()) {
            Hold h = e.hold();
            if (h.confirmed) return true;
            if (h.expiresAt <= now || h.seats.stream().anyMatch(s -> e.show().owner.get(s) != h)) return false;
            h.confirmed = true;
            return true;
        }
    }

    String seatMap(String showId, long now) {
        Show show = shows.get(showId);
        return show.seats.stream().map(s -> {
            Hold h = show.owner.get(s);
            if (h == null || !show.taken(s, now)) return s + ":free";
            return s + ":" + (h.confirmed ? "booked" : "held") + "(" + h.user + ")";
        }).collect(Collectors.joining(" "));
    }
}

public class Main {
    static String py(Object o) {
        return o == null ? "None" : o instanceof Boolean b ? (b ? "True" : "False") : o.toString();
    }

    public static void main(String[] args) throws InterruptedException {
        BookingService svc = new BookingService();
        svc.addShow(new Show("S1", List.of("A1", "A2", "A3", "A4")));
        String h1 = svc.hold("S1", List.of("A1", "A2"), "ana", 0);
        System.out.println("ana holds A1 A2: " + py(h1));
        System.out.println("ben holds A2 A3: " + py(svc.hold("S1", List.of("A2", "A3"), "ben", 10)));
        String h2 = svc.hold("S1", List.of("A3", "A4"), "ben", 10);
        System.out.println("ben holds A3 A4: " + py(h2));
        System.out.println("ana confirms at 100 s: " + py(svc.confirm(h1, 100)));
        System.out.println("ben confirms at 400 s: " + py(svc.confirm(h2, 400)));
        System.out.println("cara holds A3 at 401 s: " + py(svc.hold("S1", List.of("A3"), "cara", 401)));
        System.out.println(svc.seatMap("S1", 401));
        AtomicInteger wins = new AtomicInteger();
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 8; i++) {
            String user = "u" + i;
            threads.add(Thread.ofPlatform().start(() -> { if (svc.hold("S1", List.of("A4"), user, 500) != null) wins.incrementAndGet(); }));
        }
        for (Thread t : threads) t.join();
        System.out.println("8 buyers race for A4 at 500 s, holds granted: " + wins.get());
    }
}