Movie Ticket Booking

public enum SeatState {
  AVAILABLE,
  HELD,
  BOOKED
}

public enum HoldStatus {
  HELD,
  INVALID_REQUEST,
  SHOW_NOT_FOUND,
  SEAT_NOT_FOUND,
  SEAT_UNAVAILABLE
}

public enum ConfirmationStatus {
  BOOKED,
  HOLD_NOT_FOUND,
  HOLD_EXPIRED,
  NOT_HOLD_OWNER
}

public record Movie(String id, String title) {
  public Movie {
      if (id == null || id.isBlank()) {
          throw new IllegalArgumentException("Movie id is required");
      }
      if (title == null || title.isBlank()) {
          throw new IllegalArgumentException("Movie title is required");
      }
  }
}

public record Seat(String id) {
  public Seat {
      if (id == null || id.isBlank()) {
          throw new IllegalArgumentException("Seat id is required");
      }
  }
}

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public final class Screen {
  private final String id;
  private final Map<String, Seat> seatsById;

  public Screen(String id, List<Seat> seats) {
      if (id == null || id.isBlank()) {
          throw new IllegalArgumentException("Screen id is required");
      }
      if (seats == null || seats.isEmpty()) {
          throw new IllegalArgumentException("A screen needs seats");
      }

      this.id = id;
      this.seatsById = new LinkedHashMap<>();
      for (Seat seat : seats) {
          if (seatsById.putIfAbsent(seat.id(), seat) != null) {
              throw new IllegalArgumentException("Duplicate seat: " + seat.id());
          }
      }
  }

  public String id() {
      return id;
  }

  public List<Seat> seats() {
      return List.copyOf(seatsById.values());
  }
}

import java.time.Instant;

public final class ShowSeat {
  private final Seat seat;
  private SeatState state = SeatState.AVAILABLE;
  private String holdId;
  private String heldBy;
  private Instant expiresAt;

  public ShowSeat(Seat seat) {
      if (seat == null) {
          throw new IllegalArgumentException("Seat is required");
      }
      this.seat = seat;
  }

  public String id() {
      return seat.id();
  }

  public SeatState state() {
      return state;
  }

  public boolean isAvailable() {
      return state == SeatState.AVAILABLE;
  }

  public void placeHold(String holdId, String userId, Instant expiresAt) {
      if (!isAvailable()) {
          throw new IllegalStateException("Seat is not available: " + id());
      }
      this.state = SeatState.HELD;
      this.holdId = holdId;
      this.heldBy = userId;
      this.expiresAt = expiresAt;
  }

  public boolean isHeldBy(String expectedHoldId, String userId) {
      return state == SeatState.HELD
              && holdId.equals(expectedHoldId)
              && heldBy.equals(userId);
  }

  public boolean confirmHold(String expectedHoldId, String userId) {
      if (!isHeldBy(expectedHoldId, userId)) {
          return false;
      }
      state = SeatState.BOOKED;
      clearHoldDetails();
      return true;
  }

  public boolean releaseIfExpired(Instant now) {
      if (state == SeatState.HELD && !now.isBefore(expiresAt)) {
          state = SeatState.AVAILABLE;
          clearHoldDetails();
          return true;
      }
      return false;
  }

  private void clearHoldDetails() {
      holdId = null;
      heldBy = null;
      expiresAt = null;
  }
}

import java.time.Instant;
import java.util.List;

public record SeatHold(
      String id,
      String showId,
      String userId,
      List<String> seatIds,
      Instant expiresAt
) {
  public SeatHold {
      if (id == null || id.isBlank()
              || showId == null || showId.isBlank()
              || userId == null || userId.isBlank()) {
          throw new IllegalArgumentException("Hold identity fields are required");
      }
      if (seatIds == null || seatIds.isEmpty() || expiresAt == null) {
          throw new IllegalArgumentException("Hold seats and expiry are required");
      }
      seatIds = List.copyOf(seatIds);
  }
}

import java.time.Instant;
import java.util.List;

public record Booking(
      String id,
      String showId,
      String userId,
      List<String> seatIds,
      Instant bookedAt
) {
  public Booking {
      if (id == null || id.isBlank()
              || showId == null || showId.isBlank()
              || userId == null || userId.isBlank()) {
          throw new IllegalArgumentException("Booking identity fields are required");
      }
      if (seatIds == null || seatIds.isEmpty() || bookedAt == null) {
          throw new IllegalArgumentException("Booking seats and time are required");
      }
      seatIds = List.copyOf(seatIds);
  }
}

import java.util.Optional;

public record HoldResult(HoldStatus status, Optional<SeatHold> hold) {
  public HoldResult {
      if (status == null || hold == null) {
          throw new IllegalArgumentException("Result fields are required");
      }
  }

  public static HoldResult accepted(SeatHold hold) {
      return new HoldResult(HoldStatus.HELD, Optional.of(hold));
  }

  public static HoldResult rejected(HoldStatus status) {
      if (status == HoldStatus.HELD) {
          throw new IllegalArgumentException("Use accepted for HELD");
      }
      return new HoldResult(status, Optional.empty());
  }
}

import java.util.Optional;

public record ConfirmationResult(
      ConfirmationStatus status,
      Optional<Booking> booking
) {
  public ConfirmationResult {
      if (status == null || booking == null) {
          throw new IllegalArgumentException("Result fields are required");
      }
  }

  public static ConfirmationResult accepted(Booking booking) {
      return new ConfirmationResult(
              ConfirmationStatus.BOOKED,
              Optional.of(booking)
      );
  }

  public static ConfirmationResult rejected(ConfirmationStatus status) {
      if (status == ConfirmationStatus.BOOKED) {
          throw new IllegalArgumentException("Use accepted for BOOKED");
      }
      return new ConfirmationResult(status, Optional.empty());
  }
}

import java.time.Instant;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.ReentrantLock;

public final class Show {
  private final String id;
  private final Movie movie;
  private final Screen screen;
  private final Instant startsAt;
  private final Map<String, ShowSeat> seatsById = new LinkedHashMap<>();
  private final ReentrantLock lock = new ReentrantLock();

  public Show(String id, Movie movie, Screen screen, Instant startsAt) {
      if (id == null || id.isBlank() || movie == null
              || screen == null || startsAt == null) {
          throw new IllegalArgumentException("Complete show details are required");
      }
      this.id = id;
      this.movie = movie;
      this.screen = screen;
      this.startsAt = startsAt;
      for (Seat seat : screen.seats()) {
          seatsById.put(seat.id(), new ShowSeat(seat));
      }
  }

  public String id() {
      return id;
  }

  public Movie movie() {
      return movie;
  }

  public Screen screen() {
      return screen;
  }

  public Instant startsAt() {
      return startsAt;
  }

  public HoldStatus tryHold(
          String holdId,
          String userId,
          List<String> requestedSeatIds,
          Instant now,
          Instant expiresAt
  ) {
      if (holdId == null || holdId.isBlank()
              || userId == null || userId.isBlank()
              || requestedSeatIds == null || requestedSeatIds.isEmpty()
              || now == null || expiresAt == null
              || !expiresAt.isAfter(now)) {
          return HoldStatus.INVALID_REQUEST;
      }

      Set<String> uniqueSeatIds = new LinkedHashSet<>(requestedSeatIds);
      if (uniqueSeatIds.size() != requestedSeatIds.size()
              || uniqueSeatIds.stream().anyMatch(id -> id == null || id.isBlank())) {
          return HoldStatus.INVALID_REQUEST;
      }

      lock.lock();
      try {
          releaseExpired(now);

          // First pass: validate the complete group without changing it.
          for (String seatId : uniqueSeatIds) {
              ShowSeat seat = seatsById.get(seatId);
              if (seat == null) {
                  return HoldStatus.SEAT_NOT_FOUND;
              }
              if (!seat.isAvailable()) {
                  return HoldStatus.SEAT_UNAVAILABLE;
              }
          }

          // Second pass: all checks passed, so change the whole group.
          for (String seatId : uniqueSeatIds) {
              seatsById.get(seatId).placeHold(holdId, userId, expiresAt);
          }
          return HoldStatus.HELD;
      } finally {
          lock.unlock();
      }
  }

  public ConfirmationStatus confirmHold(SeatHold hold, Instant now) {
      lock.lock();
      try {
          if (!now.isBefore(hold.expiresAt())) {
              releaseExpired(now);
              return ConfirmationStatus.HOLD_EXPIRED;
          }

          for (String seatId : hold.seatIds()) {
              ShowSeat seat = seatsById.get(seatId);
              if (seat == null || !seat.isHeldBy(hold.id(), hold.userId())) {
                  return ConfirmationStatus.HOLD_NOT_FOUND;
              }
          }
          for (String seatId : hold.seatIds()) {
              seatsById.get(seatId).confirmHold(hold.id(), hold.userId());
          }
          return ConfirmationStatus.BOOKED;
      } finally {
          lock.unlock();
      }
  }

  public Map<String, SeatState> seatStates(Instant now) {
      lock.lock();
      try {
          releaseExpired(now);
          Map<String, SeatState> snapshot = new LinkedHashMap<>();
          for (ShowSeat seat : seatsById.values()) {
              snapshot.put(seat.id(), seat.state());
          }
          return Map.copyOf(snapshot);
      } finally {
          lock.unlock();
      }
  }

  private void releaseExpired(Instant now) {
      for (ShowSeat seat : seatsById.values()) {
          seat.releaseIfExpired(now);
      }
  }
}

import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

public final class BookingService {
  private final Map<String, Show> showsById;
  private final Map<String, SeatHold> holdsById = new ConcurrentHashMap<>();
  private final Map<String, Booking> bookingsById = new ConcurrentHashMap<>();
  private final AtomicInteger holdSequence = new AtomicInteger(1);
  private final AtomicInteger bookingSequence = new AtomicInteger(1);
  private final Clock clock;
  private final Duration holdDuration;

  public BookingService(List<Show> shows, Clock clock, Duration holdDuration) {
      if (shows == null || shows.isEmpty() || clock == null
              || holdDuration == null || holdDuration.isNegative()
              || holdDuration.isZero()) {
          throw new IllegalArgumentException("Shows, clock, and hold duration are required");
      }
      this.clock = clock;
      this.holdDuration = holdDuration;
      this.showsById = new LinkedHashMap<>();
      for (Show show : shows) {
          if (showsById.putIfAbsent(show.id(), show) != null) {
              throw new IllegalArgumentException("Duplicate show: " + show.id());
          }
      }
  }

  public HoldResult holdSeats(
          String showId,
          String userId,
          List<String> seatIds
  ) {
      Show show = showsById.get(showId);
      if (show == null) {
          return HoldResult.rejected(HoldStatus.SHOW_NOT_FOUND);
      }

      Instant now = clock.instant();
      String holdId = "H" + holdSequence.getAndIncrement();
      Instant expiresAt = now.plus(holdDuration);
      HoldStatus status = show.tryHold(
              holdId,
              userId,
              seatIds,
              now,
              expiresAt
      );
      if (status != HoldStatus.HELD) {
          return HoldResult.rejected(status);
      }

      SeatHold hold = new SeatHold(
              holdId,
              showId,
              userId,
              seatIds,
              expiresAt
      );
      holdsById.put(holdId, hold);
      return HoldResult.accepted(hold);
  }

  public ConfirmationResult confirmHold(String holdId, String userId) {
      SeatHold hold = holdsById.get(holdId);
      if (hold == null) {
          return ConfirmationResult.rejected(
                  ConfirmationStatus.HOLD_NOT_FOUND
          );
      }
      if (!hold.userId().equals(userId)) {
          return ConfirmationResult.rejected(
                  ConfirmationStatus.NOT_HOLD_OWNER
          );
      }

      Instant now = clock.instant();
      Show show = showsById.get(hold.showId());
      ConfirmationStatus status = show.confirmHold(hold, now);
      if (status != ConfirmationStatus.BOOKED) {
          if (status == ConfirmationStatus.HOLD_EXPIRED) {
              holdsById.remove(holdId, hold);
          }
          return ConfirmationResult.rejected(status);
      }

      Booking booking = new Booking(
              "B" + bookingSequence.getAndIncrement(),
              hold.showId(),
              hold.userId(),
              hold.seatIds(),
              now
      );
      bookingsById.put(booking.id(), booking);
      holdsById.remove(holdId, hold);
      return ConfirmationResult.accepted(booking);
  }

  public Map<String, SeatState> seatStates(String showId) {
      Show show = showsById.get(showId);
      if (show == null) {
          return Map.of();
      }
      return show.seatStates(clock.instant());
  }

  public Optional<Booking> booking(String bookingId) {
      return Optional.ofNullable(bookingsById.get(bookingId));
  }
}

import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.time.ZoneId;
import java.util.concurrent.atomic.AtomicReference;

public final class MutableClock extends Clock {
  private final AtomicReference<Instant> current;
  private final ZoneId zone;

  public MutableClock(Instant initialInstant, ZoneId zone) {
      if (initialInstant == null || zone == null) {
          throw new IllegalArgumentException("Initial time and zone are required");
      }
      this.current = new AtomicReference<>(initialInstant);
      this.zone = zone;
  }

  public void advance(Duration duration) {
      if (duration == null || duration.isNegative()) {
          throw new IllegalArgumentException("Advance duration cannot be negative");
      }
      current.updateAndGet(instant -> instant.plus(duration));
  }

  @Override
  public ZoneId getZone() {
      return zone;
  }

  @Override
  public Clock withZone(ZoneId newZone) {
      return new MutableClock(current.get(), newZone);
  }

  @Override
  public Instant instant() {
      return current.get();
  }
}

import java.time.Duration;
import java.time.Instant;
import java.time.ZoneOffset;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public final class MovieBookingDemo {
  public static void main(String[] args) throws Exception {
      MutableClock clock = new MutableClock(
              Instant.parse("2026-08-14T13:00:00Z"),
              ZoneOffset.UTC
      );

      BookingService normal = sampleService(clock);
      HoldResult hold = normal.holdSeats("S1", "user-a", List.of("A5", "A6"));
      System.out.println("normal hold: " + hold.status());
      String holdId = hold.hold().orElseThrow().id();
      System.out.println("normal confirm: "
              + normal.confirmHold(holdId, "user-a").status());

      BookingService group = sampleService(clock);
      group.holdSeats("S1", "first-user", List.of("A2"));
      HoldResult rejected = group.holdSeats(
              "S1",
              "second-user",
              List.of("A1", "A2")
      );
      System.out.println("group rejection: " + rejected.status());
      System.out.println("A1 after rejection: " + group.seatStates("S1").get("A1"));

      BookingService expiry = sampleService(clock);
      SeatHold expiring = expiry.holdSeats(
              "S1",
              "user-a",
              List.of("A3")
      ).hold().orElseThrow();
      clock.advance(Duration.ofMinutes(6));
      System.out.println("expired confirmation: "
              + expiry.confirmHold(expiring.id(), "user-a").status());
      System.out.println("seat reusable: "
              + expiry.holdSeats("S1", "user-b", List.of("A3")).status());

      BookingService concurrent = sampleService(clock);
      ExecutorService pool = Executors.newFixedThreadPool(2);
      CountDownLatch ready = new CountDownLatch(2);
      CountDownLatch start = new CountDownLatch(1);

      Callable<HoldStatus> userA = contender(
              concurrent,
              "user-a",
              ready,
              start
      );
      Callable<HoldStatus> userB = contender(
              concurrent,
              "user-b",
              ready,
              start
      );
      Future<HoldStatus> resultA = pool.submit(userA);
      Future<HoldStatus> resultB = pool.submit(userB);
      ready.await();
      start.countDown();

      long successCount = List.of(resultA.get(), resultB.get()).stream()
              .filter(status -> status == HoldStatus.HELD)
              .count();
      pool.shutdown();

      System.out.println("concurrent success count: " + successCount);
      System.out.println("A7 final state: "
              + concurrent.seatStates("S1").get("A7"));
      if (successCount != 1) {
          throw new AssertionError("Exactly one competing hold must succeed");
      }
  }

  private static Callable<HoldStatus> contender(
          BookingService service,
          String userId,
          CountDownLatch ready,
          CountDownLatch start
  ) {
      return () -> {
          ready.countDown();
          start.await();
          return service.holdSeats("S1", userId, List.of("A7")).status();
      };
  }

  private static BookingService sampleService(MutableClock clock) {
      Movie movie = new Movie("M1", "The Clockwork City");
      Screen screen = new Screen("SCREEN-1", List.of(
              new Seat("A1"),
              new Seat("A2"),
              new Seat("A3"),
              new Seat("A4"),
              new Seat("A5"),
              new Seat("A6"),
              new Seat("A7")
      ));
      Show show = new Show(
              "S1",
              movie,
              screen,
              Instant.parse("2026-08-14T19:00:00Z")
      );
      return new BookingService(
              List.of(show),
              clock,
              Duration.ofMinutes(5)
      );
  }
}