Design a Hotel Booking System

class Room {
    private final String id;
    private final RoomType type;
    private final double basePrice;
    // Sorted by checkIn so overlap scans can short-circuit; in production this
    // check is pushed into the database (see §6) rather than an in-memory list.
    private final List<Booking> bookings = new ArrayList<>();
 
    Room(String id, RoomType type, double basePrice) {
        this.id = id;
        this.type = type;
        this.basePrice = basePrice;
    }
 
    /** Half-open interval overlap check: [checkIn, checkOut) vs each existing booking. */
    synchronized boolean isAvailable(LocalDate checkIn, LocalDate checkOut) {
        for (Booking b : bookings) {
            if (b.getStatus() == BookingStatus.CANCELLED) continue;
            boolean overlaps = checkIn.isBefore(b.getCheckOut()) && b.getCheckIn().isBefore(checkOut);
            if (overlaps) return false;
        }
        return true;
    }
 
    synchronized void addBooking(Booking booking) { bookings.add(booking); }
 
    String getId() { return id; }
    RoomType getType() { return type; }
    double getBasePrice() { return basePrice; }
}

enum RoomType { STANDARD, DELUXE, SUITE }
enum BookingStatus { PENDING, CONFIRMED, CANCELLED, COMPLETED }
enum PaymentStatus { SUCCESS, FAILED, PENDING }
 
final class Guest {
    private final String id;
    private final String name;
    private final String contact;
 
    Guest(String id, String name, String contact) {
        this.id = id; this.name = name; this.contact = contact;
    }
    String getId() { return id; }
}
 
class Booking {
    private final String id;
    private final Guest guest;
    private final Room room;
    private final LocalDate checkIn;
    private final LocalDate checkOut;
    private volatile BookingStatus status;
    private final double amount;
 
    Booking(String id, Guest guest, Room room, LocalDate checkIn, LocalDate checkOut, double amount) {
        this.id = id;
        this.guest = guest;
        this.room = room;
        this.checkIn = checkIn;
        this.checkOut = checkOut;
        this.amount = amount;
        this.status = BookingStatus.PENDING;
    }
 
    void setStatus(BookingStatus status) { this.status = status; }
    BookingStatus getStatus() { return status; }
    LocalDate getCheckIn() { return checkIn; }
    LocalDate getCheckOut() { return checkOut; }
    Room getRoom() { return room; }
    double getAmount() { return amount; }
    String getId() { return id; }
}
 
final class Payment {
    final String id;
    final double amount;
    volatile PaymentStatus status;
 
    Payment(String id, double amount) {
        this.id = id;
        this.amount = amount;
        this.status = PaymentStatus.PENDING;
    }
}

interface PricingStrategy {
    double priceFor(Room room, LocalDate checkIn, LocalDate checkOut);
}
 
class SeasonalPricingStrategy implements PricingStrategy {
    private final Set<DayOfWeek> weekendDays = Set.of(DayOfWeek.FRIDAY, DayOfWeek.SATURDAY);
    private final double weekendMultiplier = 1.3;
 
    public double priceFor(Room room, LocalDate checkIn, LocalDate checkOut) {
        double total = 0;
        for (LocalDate date = checkIn; date.isBefore(checkOut); date = date.plusDays(1)) {
            double nightly = room.getBasePrice();
            if (weekendDays.contains(date.getDayOfWeek())) nightly *= weekendMultiplier;
            total += nightly;
        }
        return total;
    }
}

record RefundResult(double refundAmount, double cancellationFee) {}
 
interface CancellationPolicy {
    RefundResult evaluate(Booking booking, LocalDate cancellationDate);
}
 
/** Full refund if cancelled 24h+ before check-in, otherwise no refund. */
class FlexiblePolicy implements CancellationPolicy {
    public RefundResult evaluate(Booking booking, LocalDate cancellationDate) {
        long daysBefore = ChronoUnit.DAYS.between(cancellationDate, booking.getCheckIn());
        if (daysBefore >= 1) return new RefundResult(booking.getAmount(), 0);
        return new RefundResult(0, booking.getAmount());
    }
}
 
/** Tiered refund: 100% at 7+ days, 50% at 3-6 days, 0% inside 3 days. */
class ModeratePolicy implements CancellationPolicy {
    public RefundResult evaluate(Booking booking, LocalDate cancellationDate) {
        long daysBefore = ChronoUnit.DAYS.between(cancellationDate, booking.getCheckIn());
        double refundRate = daysBefore >= 7 ? 1.0 : daysBefore >= 3 ? 0.5 : 0.0;
        double refund = booking.getAmount() * refundRate;
        return new RefundResult(refund, booking.getAmount() - refund);
    }
}
 
/** No refunds, ever — e.g. non-refundable rate. */
class StrictPolicy implements CancellationPolicy {
    public RefundResult evaluate(Booking booking, LocalDate cancellationDate) {
        return new RefundResult(0, booking.getAmount());
    }
}

record WaitlistEntry(Guest guest, String hotelId, RoomType roomType, LocalDate checkIn, LocalDate checkOut) {}
 
class WaitlistManager {
    private final Map<String, Queue<WaitlistEntry>> waitlists = new ConcurrentHashMap<>();
 
    void join(WaitlistEntry entry) {
        String key = key(entry.hotelId(), entry.roomType());
        waitlists.computeIfAbsent(key, k -> new ConcurrentLinkedQueue<>()).add(entry);
    }
 
    Optional<WaitlistEntry> pollNext(String hotelId, RoomType roomType) {
        Queue<WaitlistEntry> queue = waitlists.get(key(hotelId, roomType));
        return queue == null ? Optional.empty() : Optional.ofNullable(queue.poll());
    }
 
    private String key(String hotelId, RoomType roomType) { return hotelId + ":" + roomType; }
}

interface PaymentGateway {
    Payment charge(Guest guest, double amount);
}
 
class BookingService {
    private final PricingStrategy pricingStrategy;
    private final CancellationPolicy cancellationPolicy;
    private final PaymentGateway paymentGateway;
    private final WaitlistManager waitlistManager;
 
    BookingService(PricingStrategy pricingStrategy, CancellationPolicy cancellationPolicy,
                    PaymentGateway paymentGateway, WaitlistManager waitlistManager) {
        this.pricingStrategy = pricingStrategy;
        this.cancellationPolicy = cancellationPolicy;
        this.paymentGateway = paymentGateway;
        this.waitlistManager = waitlistManager;
    }
 
    Booking createBooking(Guest guest, Room room, LocalDate checkIn, LocalDate checkOut) {
        // Step 1: hold — atomic check-and-reserve (see §6 for the race this closes).
        synchronized (room) {
            if (!room.isAvailable(checkIn, checkOut)) {
                waitlistManager.join(new WaitlistEntry(guest, room.getId(), room.getType(), checkIn, checkOut));
                throw new RoomUnavailableException(room.getId());
            }
            double amount = pricingStrategy.priceFor(room, checkIn, checkOut);
            Booking booking = new Booking(UUID.randomUUID().toString(), guest, room, checkIn, checkOut, amount);
            room.addBooking(booking); // reserved as PENDING inside the same lock as the check
            return finalizeWithPayment(booking, guest);
        }
    }
 
    // Step 2 & 3: pay, then confirm or roll back — the saga's compensating action.
    private Booking finalizeWithPayment(Booking booking, Guest guest) {
        Payment payment = paymentGateway.charge(guest, booking.getAmount());
        if (payment.status == PaymentStatus.SUCCESS) {
            booking.setStatus(BookingStatus.CONFIRMED);
        } else {
            booking.setStatus(BookingStatus.CANCELLED); // compensating action: release the hold
        }
        return booking;
    }
 
    RefundResult cancelBooking(Booking booking, LocalDate cancellationDate) {
        RefundResult result = cancellationPolicy.evaluate(booking, cancellationDate);
        booking.setStatus(BookingStatus.CANCELLED);
        waitlistManager.pollNext(booking.getRoom().getId(), booking.getRoom().getType())
                .ifPresent(entry -> {/* notify entry.guest() that a room opened up */});
        return result;
    }
}

checkIn1.isBefore(checkOut2) && checkIn2.isBefore(checkOut1)

synchronized (room) {
    if (!room.isAvailable(checkIn, checkOut)) { /* reject / waitlist */ }
    // ... reserve inside the SAME lock ...
}

-- PostgreSQL exclusion constraint sketch: DB rejects any overlapping insert atomically.
ALTER TABLE booking ADD CONSTRAINT no_overlap
  EXCLUDE USING gist (room_id WITH =, daterange(check_in, check_out) WITH &&)
  WHERE (status != 'CANCELLED');