Movie Ticket Booking

Functional Requirements

1. Movie Management:
   - Add/update movies
   - Show times and schedules

2. Theater Management:
   - Multiple theaters/screens
   - Seat layout configuration

3. Booking:
   - Select movie, show, seats
   - Multiple seat selection
   - Apply discounts/coupons

4. Payment:
   - Multiple payment methods
   - Booking confirmation
   - Refund policy

5. Seat Management:
   - Real-time seat availability
   - Block seats during booking
   - Release on timeout

Core Entities

Movie, Show, Theater, Screen, Seat,
Booking, User, Payment, Coupon

Booking Flow

1. Browse movies
2. Select movie
3. Select show (date + time)
4. Select seats
5. Apply coupons
6. Make payment
7. Get confirmation

Seat Layout

┌──────────────────────────────────────────┐
│              SCREEN                       │
├──────────────────────────────────────────┤
│  Row A: [1] [2] [3] [4] [5] [6] [7] [8]│
│  Row B: [1] [2] [3] [4] [5] [6] [7] [8]│
│  Row C: [1] [2] [3] [4] [5] [6] [7] [8]│
│  Row D: [1] [2] [3] [4] [5] [6] [7] [8]│
├──────────────────────────────────────────┤
│  Legend: [✓] Available  [✗] Booked       │
│          [●] Blocked    [★] Premium      │
└──────────────────────────────────────────┘

Seat Class

public class Seat {
    private final String seatId;
    private final SeatType type;     // STANDARD, PREMIUM, RECLINER
    private final SeatStatus status; // AVAILABLE, BOOKED, BLOCKED, MAINTENANCE
    private final double price;
    
    public boolean isAvailable() {
        return status == SeatStatus.AVAILABLE;
    }
    
    public void block() {
        if (status == SeatStatus.AVAILABLE) {
            this.status = SeatStatus.BLOCKED;
        }
    }
    
    public void book() {
        if (status == SeatStatus.BLOCKED) {
            this.status = SeatStatus.BOOKED;
        }
    }
    
    public void release() {
        if (status == SeatStatus.BLOCKED) {
            this.status = SeatStatus.AVAILABLE;
        }
    }
}

SeatMap

public class SeatMap {
    private final Map<String, Seat> seats;
    private final int rows;
    private final int columns;
    
    public List<Seat> getAvailableSeats() {
        return seats.values().stream()
            .filter(Seat::isAvailable)
            .collect(Collectors.toList());
    }
    
    public boolean blockSeats(List<String> seatIds) {
        // Atomic blocking - all or nothing
        synchronized (this) {
            List<Seat> seatsToBlock = seatIds.stream()
                .map(seats::get)
                .collect(Collectors.toList());
            
            if (seatsToBlock.stream().allMatch(Seat::isAvailable)) {
                seatsToBlock.forEach(Seat::block);
                return true;
            }
            return false;
        }
    }
}

Seat Pricing

public class SeatPricing {
    public double calculatePrice(Seat seat, Show show) {
        double basePrice = seat.getPrice();
        
        // Apply time-based pricing
        if (show.isPeakTime()) {
            basePrice *= 1.2;
        }
        
        // Apply weekend pricing
        if (show.isWeekend()) {
            basePrice *= 1.3;
        }
        
        return basePrice;
    }
}

Booking Service

public class BookingService {
    private final SeatMap seatMap;
    private final PaymentService paymentService;
    private final NotificationService notificationService;
    
    public Booking createBooking(User user, Show show, 
                                 List<String> seatIds) {
        // 1. Block seats (atomic)
        if (!seatMap.blockSeats(seatIds)) {
            throw new SeatsNotAvailableException();
        }
        
        // 2. Create booking with timeout
        Booking booking = new Booking(user, show, seatIds);
        booking.setTimeout(5 * 60 * 1000); // 5 minutes
        
        // 3. Start timeout timer
        scheduleTimeout(booking);
        
        return booking;
    }
    
    public void confirmBooking(Booking booking, Payment payment) {
        // 1. Process payment
        paymentService.process(payment);
        
        // 2. Book seats
        booking.getSeatIds().forEach(id -> seatMap.getSeat(id).book());
        
        // 3. Update booking status
        booking.setStatus(BookingStatus.CONFIRMED);
        
        // 4. Send confirmation
        notificationService.sendBookingConfirmation(booking);
    }
    
    private void scheduleTimeout(Booking booking) {
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                if (booking.getStatus() == BookingStatus.PENDING) {
                    // Release blocked seats
                    booking.getSeatIds().forEach(
                        id -> seatMap.getSeat(id).release()
                    );
                    booking.setStatus(BookingStatus.EXPIRED);
                }
            }
        }, booking.getTimeout());
    }
}

Booking Class

public class Booking {
    private final String bookingId;
    private final User user;
    private final Show show;
    private final List<String> seatIds;
    private BookingStatus status;
    private final LocalDateTime createdAt;
    private double totalAmount;
    
    public enum BookingStatus {
        PENDING, CONFIRMED, CANCELLED, EXPIRED
    }
}

Payment Processing

public class PaymentService {
    public PaymentResult process(Booking booking, PaymentDetails details) {
        // 1. Validate payment details
        validatePayment(details);
        
        // 2. Calculate total
        double total = calculateTotal(booking);
        
        // 3. Process with payment provider
        return paymentProvider.charge(details, total);
    }
    
    private double calculateTotal(Booking booking) {
        SeatPricing pricing = new SeatPricing();
        return booking.getSeatIds().stream()
            .mapToDouble(id -> pricing.calculatePrice(
                seatMap.getSeat(id), booking.getShow()))
            .sum();
    }
}

Follow-up Questions

1. How to handle concurrent seat selection?
   → Atomic seat blocking
   → Optimistic locking with version
   → Distributed locks for scalability

2. How to handle refunds?
   → Refund policy per show
   → Partial refunds for partial cancellation
   → Refund to original payment method

3. How to handle seat selection timeout?
   → Timer-based release
   → Block duration configuration
   → Notification before expiry

4. How to handle multiple shows at same time?
   → Independent seat maps per show
   → Shared theater management
   → Conflict detection

5. How to handle dynamic pricing?
   → Demand-based pricing
   → Early bird discounts
   → Group discounts

Design Patterns

Database Schema

movies (id, title, genre, duration)
theaters (id, name, location)
screens (id, theater_id, seat_config)
seats (id, screen_id, row, col, type, price)
shows (id, movie_id, screen_id, time, price)
bookings (id, user_id, show_id, status, total)
booking_seats (booking_id, seat_id)
payments (id, booking_id, amount, method, status)