Design a Movie Ticket Booking System

public enum BookingStatus {
    REQUESTED, PENDING, CONFIRMED, CHECKED_IN, CANCELED, ABANDONED
}

public enum SeatType {
    REGULAR, PREMIUM, ACCESSIBLE, SHIPPED, EMERGENCY_EXIT, OTHER
}

public enum AccountStatus {
    ACTIVE, BLOCKED, BANNED, COMPROMISED, ARCHIVED, UNKNOWN
}

public enum PaymentStatus {
    UNPAID, PENDING, COMPLETED, FILLED, DECLINED, CANCELLED, ABANDONED, SETTLING, SETTLED, REFUNDED
}

public class Address {
    private String streetAddress;
    private String city;
    private String state;
    private String zipCode;
    private String country;
}

// For simplicity, we are not defining getter and setter functions. The reader can
// assume that all class attributes are private and accessed through their respective
// public getter method and modified only through their public setter method.

public class Account {
    private String id;
    private String password;
    private AccountStatus status;

    public boolean resetPassword();
}

public abstract class Person {
    private String name;
    private Address address;
    private String email;
    private String phone;

    private Account account;
}

public class Customer extends Person {
    public boolean makeBooking(Booking booking);

    public List<Booking> getBookings();
}

public class Admin extends Person {
    public boolean addMovie(Movie movie);

    public boolean addShow(Show show);

    public boolean blockUser(Customer customer);
}

public class FrontDeskOfficer extends Person {
    public boolean createBooking(Booking booking);
}

public class Guest {
    public bool registerAccount();
}

public class Show {
    private int showId;
    private Date createdOn;
    private Date startTime;
    private Date endTime;
    private CinemaHall playedAt;
    private Movie movie;
}

public class Movie {
    private String title;
    private String description;
    private int durationInMins;
    private String language;
    private Date releaseDate;
    private String country;
    private String genre;
    private Admin movieAddedBy;

    private List<Show> shows;

    public List<Show> getShows();
}

public class Booking {
    private String bookingNumber;
    private int numberOfSeats;
    private Date createdOn;
    private BookingStatus status;

    private Show show;
    private List<ShowSeat> seats;
    private Payment payment;

    public boolean makePayment(Payment payment);

    public boolean cancel();

    public boolean assignSeats(List<ShowSeat> seats);
}

public class ShowSeat extends CinemaHallSeat {
    private int showSeatId;
    private boolean isReserved;
    private double price;
}

public class Payment {
    private double amount;
    private Date createdOn;
    private int transactionId;
    private PaymentStatus status;
}

public class City {
    private String name;
    private String state;
    private String zipCode;
}

public class Cinema {
    private String name;
    private int totalCinemaHalls;
    private Address location;

    private List<CinemaHall> halls;
}

public class CinemaHall {
    private String name;
    private int totalSeats;

    private List<CinemaHallSeat> seats;
    private List<Show> shows;
}

public interface Search {
    public List<Movie> searchByTitle(String title);

    public List<Movie> searchByLanguage(String language);

    public List<Movie> searchByGenre(String genre);

    public List<Movie> searchByReleaseDate(Date relDate);

    public List<Movie> searchByCity(String cityName);
}

public class Catalog implements Search {
    HashMap<String, List<Movie>> movieTitles;
    HashMap<String, List<Movie>> movieLanguages;
    HashMap<String, List<Movie>> movieGenres;
    HashMap<Date, List<Movie>> movieReleaseDates;
    HashMap<String, List<Movie>> movieCities;

    public List<Movie> searchByTitle(String title) {
        return movieTitles.get(title);
    }

    public List<Movie> searchByLanguage(String language) {
        return movieLanguages.get(language);
    }

    // ...

    public List<Movie> searchByCity(String cityName) {
        return movieCities.get(cityName);
    }
}

SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;

BEGIN TRANSACTION;

    -- Suppose we intend to reserve three seats (IDs: 54, 55, 56) for ShowID=99 
    Select * From ShowSeat where ShowID=99 && ShowSeatID in (54, 55, 56) && isReserved=0 

    -- if the number of rows returned by the above statement is NOT three, we can return failure to the user.
    update ShowSeat table...
    update Booking table ...

COMMIT TRANSACTION;

import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.ResultSet;

public class Customer extends Person {

    public boolean makeBooking(Booking booking) {
        List<ShowSeat> seats = booking.getSeats();
        Integer seatIds[] = new Integer[seats.size()];
        int index = 0;
        for (ShowSeat seat : seats) {
            seatIds[index++] = seat.getShowSeatId();
        }

        Connection dbConnection = null;
        try {
            dbConnection = getDBConnection();
            dbConnection.setAutoCommit(false);
            // ‘Serializable’ is the highest isolation level and guarantees safety from
            // Dirty, Nonrepeatable, and Phantoms reads
            dbConnection.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);

            Statement st = dbConnection.createStatement();
            String selectSQL = "Select * From ShowSeat where ShowID=? && ShowSeatID in (?) && isReserved=0";
            PreparedStatement preparedStatement = dbConnection.prepareStatement(selectSQL);
            preparedStatement.setInt(1, booking.getShow().getShowId());
            Array array = dbConnection.createArrayOf("INTEGER", seatIds);
            preparedStatement.setArray(2, array);

            ResultSet rs = preparedStatement.executeQuery();
            // With TRANSACTION_SERIALIZABLE all the read rows will have the write lock, so
            // we can
            // safely assume that no one else is modifying them.
            if (rs.next()) {
                rs.last(); // move to the last row, to calculate the row count
                int rowCount = rs.getRow();
                // check if we have expected number of rows, if not, this means another process
                // is
                // trying to process at least one of the same row, if that is the case we
                // should not process this booking.
                if (rowCount == seats.size()) {
                    // update ShowSeat table...
                    // update Booking table ...
                    dbConnection.commit();
                    return true;
                }
            }
        } catch (SQLException e) {
            dbConnection.rollback();
            System.out.println(e.getMessage());
        }
        return false;
    }
}

I just read a lesson on **Design a Movie Ticket Booking System** (OO & Low-Level Design) and want to truly understand it. Explain Design a Movie Ticket Booking System from first principles using ONE vivid real-world analogy and a visual mental model — draw it as ASCII art or a clear step-by-step diagram — with a concrete example using real numbers. Then ask me one question to check I got the mental picture, and wait for my reply. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

Teach me **Design a Movie Ticket Booking System** interactively. Ask me ONE guiding question at a time, wait for my answer, and adapt to my confusion — build the idea with me step by step instead of explaining it all at once. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

Quiz me on **Design a Movie Ticket Booking System** with 5 questions, easy to tricky, ONE at a time. Tell me if each answer is right; at the end, explain clearly what I got wrong and why. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

Help me remember **Design a Movie Ticket Booking System** for the long term: give the one-sentence intuition, a memorable hook/mnemonic, a tiny worked example, and 3 active-recall flashcards (Q -> A). If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.