// Technical approach - just data containers
public class MovieData {
    private String genre; // Any string allowed, even nonsensical ones
    // Other properties...
}

// Philosophical approach - semantic boundaries
public class Movie {
    private MovieGenre genre; // Only valid movie genres allowed
    // Other properties...
}

public enum MovieGenre {
    ACTION, COMEDY, DRAMA, HORROR, SCIENCE_FICTION, ROMANCE, 
    DOCUMENTARY, ANIMATION, THRILLER, FANTASY, MUSICAL, WESTERN
}

public final class Movie {
    private final UUID id;
    private final String title; // Part of core identity
    private final LocalDate releaseDate; // Part of core identity
    private String synopsis; // Not part of core identity - can change
    
    // No setters for identity attributes
    public void updateSynopsis(String newSynopsis) {
        this.synopsis = newSynopsis;
    }
}

public final class Person {
    private final String firstName; // Immutable - defines identity
    private final String lastName; // Immutable - defines identity
    private final LocalDate birthDate; // Immutable - defines identity
    private String email; // Mutable - not part of core identity
    
    // No setters for identity fields
    public void updateEmail(String newEmail) {
        // Validation logic
        this.email = newEmail;
    }
}

// Entity - has identity beyond its attributes
public class User {
    private final UUID id; // Distinct identity
    private String username;
    private String email;
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id.equals(user.id); // Equality based on identity
    }
}

// Value Object - is its attributes
public final class Money {
    private final BigDecimal amount;
    private final Currency currency;
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Money money = (Money) o;
        return amount.equals(money.amount) && 
               currency.equals(money.currency); // Equality based on attributes
    }
}

// Poor domain vocabulary
public void process(String status, double amount) {
    // Implementation
}

// Rich domain vocabulary
public void processRefund(RefundStatus status, Money amount) {
    // Implementation
}

// Traditional approach - objects as passive data
public class BookingService {
    public void createBooking(User user, ShowTime showTime, List<Seat> seats) {
        // Service manipulates passive objects
        Booking booking = new Booking();
        booking.setUser(user);
        booking.setShowTime(showTime);
        booking.setSeats(seats);
        booking.setStatus(BookingStatus.INITIATED);
        bookingRepository.save(booking);
    }
}

// Philosophical approach - objects as active agents
public class BookingService {
    public Booking initiateBooking(User user, ShowTime showTime, List<Seat> seats) {
        // Objects have agency and behavior
        if (!showTime.areSeatsAvailable(seats)) {
            throw new SeatsUnavailableException(seats);
        }
        
        Booking booking = Booking.create(user, showTime, seats);
        bookingRepository.save(booking);
        return booking;
    }
}

public class Booking {
    // Fields...
    
    public static Booking create(User user, ShowTime showTime, List<Seat> seats) {
        // Booking creates itself with valid state
        Booking booking = new Booking(UUID.randomUUID(), user, showTime, seats);
        booking.status = BookingStatus.INITIATED;
        return booking;
    }
    
    public boolean confirm() {
        // Booking controls its own state transitions
        if (status != BookingStatus.PAYMENT_PENDING) {
            return false;
        }
        this.status = BookingStatus.CONFIRMED;
        return true;
    }
}

// Disrespects object autonomy
public class SeatManager {
    public void markSeatAsBooked(Seat seat) {
        seat.status = SeatStatus.BOOKED; // Directly manipulates state
    }
}

// Respects object autonomy
public class SeatManager {
    public boolean requestSeatBooking(Seat seat) {
        return seat.book(); // Asks the seat to perform an action
    }
}

public class Seat {
    private SeatStatus status;
    
    public synchronized boolean book() {
        // Seat controls its own state transitions
        if (status != SeatStatus.AVAILABLE) {
            return false;
        }
        status = SeatStatus.BOOKED;
        return true;
    }
}

// Traditional view: Method calling
bookingService.cancelBooking(booking);

// Philosophical view: Message passing
booking.requestCancellation();

public class Movie {
    private final Set<MovieGenre> genres;
    
    public boolean isOfGenre(MovieGenre genre) {
        return genres.contains(genre);
    }
    
    public boolean isSuitableForChildren() {
        // Movie knows what makes it suitable for children
        return !genres.contains(MovieGenre.HORROR) && 
               !genres.contains(MovieGenre.THRILLER);
    }
}

public class BookingConfirmation {
    private final Booking booking;
    
    public String generateConfirmationMessage() {
        // BookingConfirmation has a personality - it's enthusiastic and helpful
        return "Great news! Your booking for " + booking.getMovie().getTitle() + 
               " is confirmed. We look forward to seeing you on " + 
               booking.getShowTime().getFormattedDateTime() + "!";
    }
    
    public void sendTo(User user) {
        // BookingConfirmation knows its purpose - to inform and reassure
        notificationService.sendMessage(
            user.getPreferredContactMethod(),
            "Your movie booking is confirmed!",
            generateConfirmationMessage()
        );
    }
}

// Before impersonation thinking
public class Movie {
    private String title;
    
    public void setTitle(String title) {
        this.title = title;
    }
}

// After impersonation thinking
public final class Movie {
    private final String title; // Immutable - part of core identity
    
    // No setter for title - "As a Movie, my title defines who I am"
}

public class Person {
    private final BigDecimal salary; // Private information
    
    // Restricted access based on authority
    public BigDecimal getSalaryForTaxAuthority(TaxAuthority authority) {
        if (authority.hasJurisdictionOver(this)) {
            return this.salary;
        }
        throw new UnauthorizedAccessException("You have no jurisdiction over me");
    }
    
    // Different authority, different access
    public BigDecimal getSalaryForEmployer(Employer employer) {
        if (this.isEmployedBy(employer)) {
            return this.salary;
        }
        throw new UnauthorizedAccessException("You are not my employer");
    }
    
    // No general public access
    // No public getSalary() method
}

// Before impersonation thinking
public class Theatre {
    private List<Screen> screens;
    
    public void addScreen(Screen screen) {
        screens.add(screen);
    }
    
    public void removeScreen(Screen screen) {
        screens.remove(screen);
    }
}

// After impersonation thinking
public final class Theatre {
    private final Set<Screen> screens; // Immutable collection
    
    public Theatre(String name, Address location, Set<Screen> screens) {
        // Theatre is created with all its screens - "As a Theatre, my screens define part of my identity"
        this.screens = Collections.unmodifiableSet(new HashSet<>(screens));
    }
    
    // No methods to add or remove screens - "As a Theatre, my physical structure doesn't change frequently"
}

/**
 * Represents a Movie in the cinema system.
 * 
 * As a Movie, my identity consists of my title, release date, and duration.
 * These attributes are immutable because they define what movie I am.
 * 
 * As a Movie, I own my cast and crew lists. These collections are part of
 * what makes me the specific movie that I am, though they may be amended
 * with additional information over time.
 * 
 * As a Movie, I know my genres and can answer questions about my content
 * and audience suitability.
 */
public final class Movie {
    // Implementation...
}

// Conventional encapsulation - mechanical privacy
public class Customer {
    private String name;
    private String taxId;
    private CreditScore creditScore;
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getTaxId() { return taxId; }
    public void setTaxId(String taxId) { this.taxId = taxId; }
    public CreditScore getCreditScore() { return creditScore; }
    public void setCreditScore(CreditScore creditScore) { this.creditScore = creditScore; }
}

// True encapsulation - authority-based access control
public class Customer {
    private final String name; // Identity - immutable
    private final String taxId; // Sensitive - restricted access
    private CreditScore creditScore; // Controlled by authorized parties
    
    // Identity is accessible to all
    public String getName() { return name; }
    
    // Tax ID only accessible to tax authorities
    public String getTaxIdForAuthority(TaxAuthority authority) {
        if (authority.isLegitimate()) {
            return taxId;
        }
        throw new UnauthorizedAccessException("Not a legitimate tax authority");
    }
    
    // Credit score only accessible to financial institutions with consent
    public CreditScore getCreditScoreForInstitution(FinancialInstitution institution) {
        if (hasConsentedTo(institution)) {
            return creditScore;
        }
        throw new UnauthorizedAccessException("No consent given to this institution");
    }
    
    // Only credit bureaus can update credit score
    public void updateCreditScore(CreditScore newScore, CreditBureau bureau) {
        if (bureau.isRecognized()) {
            this.creditScore = newScore;
        } else {
            throw new UnauthorizedAccessException("Not a recognized credit bureau");
        }
    }
}

public class Medical Record {
    private final Patient patient;
    private final Doctor attendingPhysician;
    private final List<Diagnosis> diagnoses;
    private final List<Prescription> prescriptions;
    private final List<LabResult> labResults;
    
    // Patient can see basic information
    public MedicalSummary getSummaryForPatient() {
        return new MedicalSummary(diagnoses, prescriptions);
    }
    
    // Attending physician can see everything
    public CompleteMedicalRecord getRecordForPhysician(Doctor requestingPhysician) {
        if (requestingPhysician.equals(attendingPhysician) || patient.hasAuthorized(requestingPhysician)) {
            return new CompleteMedicalRecord(diagnoses, prescriptions, labResults);
        }
        throw new UnauthorizedAccessException("Physician not authorized to view this record");
    }
    
    // Insurance companies can see billing-relevant information
    public BillingRecord getRecordForInsurance(InsuranceProvider provider) {
        if (patient.getInsuranceProvider().equals(provider)) {
            return new BillingRecord(diagnoses, prescriptions);
        }
        throw new UnauthorizedAccessException("Not the patient's insurance provider");
    }
}

public class BankAccount {
    private final Customer owner;
    private final AccountNumber accountNumber;
    private Money balance;
    private List<Transaction> transactions;
    
    // Owner can see everything
    public AccountDetails getDetailsForOwner(Customer requestingCustomer) {
        if (requestingCustomer.equals(owner)) {
            return new AccountDetails(accountNumber, balance, transactions);
        }
        throw new UnauthorizedAccessException("Not the account owner");
    }
    
    // Bank staff can see details for legitimate purposes
    public AccountDetails getDetailsForBankStaff(BankEmployee employee, AccessPurpose purpose) {
        if (employee.hasAccessLevel(AccessLevel.CUSTOMER_ACCOUNTS) && purpose.isLegitimate()) {
            return new AccountDetails(accountNumber, balance, transactions);
        }
        throw new UnauthorizedAccessException("Unauthorized access attempt");
    }
    
    // Regulatory authorities can audit
    public AuditRecord getAuditRecordForRegulator(RegulatoryAuthority authority, AuditRequest request) {
        if (authority.isRecognized() && request.isValid()) {
            return new AuditRecord(accountNumber, transactions);
        }
        throw new UnauthorizedAccessException("Invalid audit request");
    }
}

public class Employee {
    private final String name; // Immutable identity
    private Department department; // Can change
    private Money salary; // Sensitive - restricted changes
    
    // Department changes require manager approval
    public void changeDepartment(Department newDepartment, Manager approver) {
        if (approver.canManage(this) || approver.manages(newDepartment)) {
            this.department = newDepartment;
        } else {
            throw new UnauthorizedOperationException("Manager not authorized to make this change");
        }
    }
    
    // Salary changes require HR and management approval
    public void adjustSalary(Money newSalary, HRRepresentative hr, Manager manager) {
        if (hr.isAuthorizedForCompensation() && manager.canManage(this)) {
            this.salary = newSalary;
        } else {
            throw new UnauthorizedOperationException("Insufficient authority for salary adjustment");
        }
    }
}

// Technical type selection
public class Movie {
    private String genre; // Just a string
    private int durationMinutes; // Just a number
    private String rating; // Just a string
}

// Semantic type selection
public class Movie {
    private MovieGenre genre; // A defined category with meaning
    private Duration duration; // A time concept, not just a number
    private Rating rating; // A structured concept with validation rules
}

// Poor semantic clarity
public class Book {
    private String genre; // Any string is accepted
    
    public void setGenre(String genre) {
        this.genre = genre; // No validation against actual book genres
    }
}

// Strong semantic clarity
public class Book {
    private BookGenre genre; // Only valid genres accepted
    
    public void setGenre(BookGenre genre) {
        this.genre = Objects.requireNonNull(genre, "Genre must be specified");
    }
}

public enum BookGenre {
    FICTION_ADVENTURE,
    FICTION_CONTEMPORARY,
    FICTION_HISTORICAL,
    FICTION_MYSTERY,
    FICTION_SCIENCE_FICTION,
    NON_FICTION_BIOGRAPHY,
    NON_FICTION_HISTORY,
    NON_FICTION_SCIENCE,
    NON_FICTION_SELF_HELP
}

// Primitive obsession - using technical types
public class Product {
    private String name;
    private double price; // Just a number - is it dollars? euros? yen?
    
    public void applyDiscount(double percentage) {
        this.price = this.price * (1 - percentage/100); // Prone to errors
    }
}

// Domain-specific types
public class Product {
    private ProductName name; // Not just any string
    private Money price; // Amount with currency
    
    public void applyDiscount(Percentage percentage) {
        this.price = this.price.discountBy(percentage);
    }
}

public final class Money {
    private final BigDecimal amount;
    private final Currency currency;
    
    // Constructor with validation
    public Money(BigDecimal amount, Currency currency) {
        if (amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Amount cannot be negative");
        }
        this.amount = amount;
        this.currency = Objects.requireNonNull(currency);
    }
    
    public Money discountBy(Percentage percentage) {
        return new Money(
            amount.multiply(BigDecimal.ONE.subtract(percentage.asFraction())),
            currency
        );
    }
    
    // No setters - immutable value object
}

// Flat structure - misses the taxonomy
public class PaymentProcessor {
    public void processPayment(String paymentType, String accountNumber, double amount) {
        switch (paymentType) {
            case "CREDIT_CARD":
                // Process credit card
                break;
            case "DEBIT_CARD":
                // Process debit card
                break;
            case "BANK_TRANSFER":
                // Process bank transfer
                break;
            // And so on...
        }
    }
}

// Taxonomical structure - reflects domain relationships
public abstract class PaymentMethod {
    public abstract boolean processPayment(Money amount);
}

public abstract class CardPayment extends PaymentMethod {
    protected final CardNumber cardNumber;
    protected final ExpiryDate expiryDate;
    protected final SecurityCode securityCode;
    
    // Common card processing logic
}

public class CreditCardPayment extends CardPayment {
    private final CreditLimit creditLimit;
    
    @Override
    public boolean processPayment(Money amount) {
        // Credit card specific processing
    }
}

public class DebitCardPayment extends CardPayment {
    private final BankAccount linkedAccount;
    
    @Override
    public boolean processPayment(Money amount) {
        // Debit card specific processing
    }
}

public class BankTransferPayment extends PaymentMethod {
    private final BankAccount fromAccount;
    private final BankAccount toAccount;
    
    @Override
    public boolean processPayment(Money amount) {
        // Bank transfer specific processing
    }
}

// Primitive obsession - using basic types for domain concepts
public class UserRegistration {
    public User registerUser(String email, String password, int age, String country) {
        // Validation logic scattered throughout the method
        if (!email.contains("@")) {
            throw new IllegalArgumentException("Invalid email format");
        }
        if (password.length() < 8) {
            throw new IllegalArgumentException("Password too short");
        }
        if (age < 18) {
            throw new IllegalArgumentException("Must be 18 or older");
        }
        // More validation...
        
        return new User(email, password, age, country);
    }
}

// Domain-specific types
public class UserRegistration {
    public User registerUser(EmailAddress email, Password password, Age age, Country country) {
        // Validation already handled by the types
        return new User(email, password, age, country);
    }
}

public final class EmailAddress {
    private final String value;
    
    public EmailAddress(String value) {
        if (!isValidEmail(value)) {
            throw new InvalidEmailException(value);
        }
        this.value = value;
    }
    
    private boolean isValidEmail(String email) {
        // Email validation logic
        return email != null && email.contains("@");
    }
    
    // No setters - immutable value object
}

public final class Password {
    private final String hashedValue;
    
    public Password(String plaintext) {
        if (plaintext.length() < 8) {
            throw new WeakPasswordException("Password too short");
        }
        this.hashedValue = hashPassword(plaintext);
    }
    
    private String hashPassword(String plaintext) {
        // Password hashing logic
        return "hashed_" + plaintext; // Simplified for example
    }
    
    // No setters - immutable value object
}

// Types as documentation
public class FlightBookingService {
    public BoardingPass bookFlight(
        Passenger passenger, 
        Flight flight, 
        SeatClass seatClass, 
        PaymentMethod paymentMethod
    ) {
        // Implementation
    }
}

// Obscured domain concepts
public class FlightBookingService {
    public String bookFlight(
        String passengerDetails, 
        String flightNumber, 
        int classCode, 
        String paymentInfo
    ) {
        // Implementation
    }
}

public final class Person {
    private final String firstName; // Immutable - defines identity
    private final String lastName; // Immutable - defines identity
    private final LocalDate dateOfBirth; // Immutable - historical fact
    private ContactInformation contactInfo; // Mutable - changes over time
    private EmploymentStatus employment; // Mutable - changes over time
    
    // Constructor with validation for identity attributes
    
    // No setters for identity attributes
    
    // Controlled methods to update non-identity attributes
    public void updateContactInformation(ContactInformation newContactInfo) {
        this.contactInfo = Objects.requireNonNull(newContactInfo);
    }
}

public final class Movie {
    private final String title; // Core identity - passes replacement test
    private final LocalDate releaseDate; // Core identity - historical fact
    private final Set<Person> directors; // Core identity - key creative force
    private String synopsis; // Not core identity - can be revised
    private Rating criticRating; // Not core identity - subjective assessment
    
    // Constructor with validation for identity attributes
    
    // No setters for identity attributes
    
    // Controlled methods for non-identity attributes
    public void updateSynopsis(String newSynopsis) {
        this.synopsis = Objects.requireNonNull(newSynopsis);
    }
}

public class User {
    private final UUID id; // Intrinsic identity
    private String username; // Can change without affecting identity
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id.equals(user.id); // Equality based only on identity
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

public final class Money {
    private final BigDecimal amount;
    private final Currency currency;
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Money money = (Money) o;
        return amount.equals(money.amount) && 
               currency.equals(money.currency); // Equality based on all attributes
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(amount, currency);
    }
}

public final class CustomerEvent {
    private final UUID customerId; // Link to the entity's identity
    private final LocalDateTime timestamp;
    private final CustomerEventType type;
    private final Map<String, Object> data;
    
    // Constructor with validation
    
    // Completely immutable - no setters
}

public class CustomerEventStream {
    private final UUID customerId;
    private final List<CustomerEvent> events = new ArrayList<>();
    
    public void addEvent(CustomerEventType type, Map<String, Object> data) {
        events.add(new CustomerEvent(customerId, LocalDateTime.now(), type, data));
    }
    
    public Customer reconstructCurrentState() {
        Customer customer = null;
        
        for (CustomerEvent event : events) {
            if (event.getType() == CustomerEventType.CREATED) {
                customer = createFromEvent(event);
            } else if (customer != null) {
                customer = applyEvent(customer, event);
            }
        }
        
        return customer;
    }
    
    // Helper methods to create and apply events
}

// Base type with fixed structure
public abstract class MenuItem {
    private final String name;
    private final Money basePrice;
    private final List<Allergen> allergens;
    
    // Constructor with validation
    
    // Abstract methods to be implemented by subtypes
    public abstract String getDescription();
    public abstract Money calculatePrice(List<Customization> customizations);
}

// Concrete implementations for different menu categories
public class EntreeItem extends MenuItem {
    private final List<Side> includedSides;
    
    @Override
    public String getDescription() {
        // Entree-specific description
    }
    
    @Override
    public Money calculatePrice(List<Customization> customizations) {
        // Entree-specific pricing logic
    }
}

public class BeverageItem extends MenuItem {
    private final boolean alcoholic;
    
    @Override
    public String getDescription() {
        // Beverage-specific description
    }
    
    @Override
    public Money calculatePrice(List<Customization> customizations) {
        // Beverage-specific pricing logic
    }
}

// Type-safe customization system
public interface Customization {
    Money getPriceAdjustment();
    boolean isApplicableTo(MenuItem item);
}

public class ExtraIngredient implements Customization {
    private final Ingredient ingredient;
    private final Money priceAdjustment;
    
    @Override
    public Money getPriceAdjustment() {
        return priceAdjustment;
    }
    
    @Override
    public boolean isApplicableTo(MenuItem item) {
        // Logic to determine if this extra ingredient is applicable
    }
}

// Theatre-specific seat type system
public final class SeatTypeRegistry {
    private final Map<String, SeatType> types = new HashMap<>();
    
    // Register a new type (only at theatre setup)
    public void registerType(String code, String name, BigDecimal priceMultiplier) {
        if (types.containsKey(code)) {
            throw new DuplicateSeatTypeException(code);
        }
        types.put(code, new SeatType(code, name, priceMultiplier));
    }
    
    // Type-safe lookup
    public SeatType getType(String code) {
        SeatType type = types.get(code);
        if (type == null) {
            throw new UnknownSeatTypeException(code);
        }
        return type;
    }
    
    // Inner class for type safety
    public static final class SeatType {
        private final String code;
        private final String name;
        private final BigDecimal priceMultiplier;
        
        // Private constructor, only created through registry
        private SeatType(String code, String name, BigDecimal priceMultiplier) {
            this.code = code;
            this.name = name;
            this.priceMultiplier = priceMultiplier;
        }
        
        // Getters but no setters - immutable
    }
}

// Usage example
public final class Theatre {
    private final String name;
    private final SeatTypeRegistry seatTypes;
    
    public Theatre(String name) {
        this.name = name;
        this.seatTypes = new SeatTypeRegistry();
        initializeDefaultSeatTypes();
    }
    
    private void initializeDefaultSeatTypes() {
        seatTypes.registerType("STD", "Standard", new BigDecimal("1.0"));
        seatTypes.registerType("PRM", "Premium", new BigDecimal("1.5"));
        seatTypes.registerType("VIP", "VIP", new BigDecimal("2.0"));
    }
    
    // Theatre-specific seat type
    public void addCustomSeatType(String code, String name, BigDecimal multiplier) {
        seatTypes.registerType(code, name, multiplier);
    }
}

// Sales bounded context
package com.example.sales;

public class Customer {
    private final UUID id;
    private final String name;
    private final SalesRepresentative assignedRep;
    private final List<Opportunity> opportunities;
    
    // Sales-specific customer behavior
    public void addOpportunity(Product product, BigDecimal estimatedValue) {
        opportunities.add(new Opportunity(this, product, estimatedValue));
    }
}

// Shipping bounded context
package com.example.shipping;

public class Customer {
    private final UUID id;
    private final String name;
    private final Address shippingAddress;
    private final List<ShippingPreference> preferences;
    
    // Shipping-specific customer behavior
    public DeliveryRoute calculateOptimalDeliveryRoute() {
        // Shipping-specific logic
    }
}

// Core domain concept with varying implementations
public interface PricingStrategy {
    Money calculatePrice(Booking booking);
}

public class StandardPricingStrategy implements PricingStrategy {
    @Override
    public Money calculatePrice(Booking booking) {
        // Standard pricing algorithm
    }
}

public class PeakSeasonPricingStrategy implements PricingStrategy {
    @Override
    public Money calculatePrice(Booking booking) {
        // Peak season pricing algorithm
    }
}

public class PromotionalPricingStrategy implements PricingStrategy {
    private final Promotion promotion;
    
    @Override
    public Money calculatePrice(Booking booking) {
        // Apply promotion to standard price
    }
}

// Usage
public class BookingService {
    private final PricingStrategyFactory pricingStrategyFactory;
    
    public Money calculateBookingPrice(Booking booking) {
        PricingStrategy strategy = pricingStrategyFactory.getStrategyFor(booking);
        return strategy.calculatePrice(booking);
    }
}

// Core domain event
public class BookingCreatedEvent {
    private final UUID bookingId;
    private final UUID customerId;
    private final LocalDateTime bookingTime;
    private final Money totalAmount;
    
    // Constructor and getters
}

// Event listeners can be added without modifying core domain
public class LoyaltyPointsCalculator implements EventListener<BookingCreatedEvent> {
    @Override
    public void onEvent(BookingCreatedEvent event) {
        // Award loyalty points for the booking
    }
}

public class MarketingCampaignTracker implements EventListener<BookingCreatedEvent> {
    @Override
    public void onEvent(BookingCreatedEvent event) {
        // Track conversion from marketing campaign
    }
}

public class Person {
    private String bankAddress;
}

public class Bank {
    private String address;
}

public class User { /* ... */ }
public class Account { /* ... */ }
public class Person { /* ... */ }

// Creates one mental model
public void process(Data data) {
    // Implementation
}

// Creates an entirely different mental model
public void calculateMonthlyInterest(LoanAccount account) {
    // Implementation
}

// Misaligned with domain language
public class MovieShow {
    private Film filmContent;
    private ScreenRoom venue;
    private TimeSlot period;
}

// Aligned with domain language
public class Screening {
    private Movie movie;
    private Theatre theatre;
    private ShowTime showTime;
}

// Inconsistent naming breaks conceptual integrity
public class Customer {
    // ...
}

public class ClientAccount {  // Is a Client different from a Customer?
    private Customer owner;
    // ...
}

public class PatronPreferences {  // Is a Patron different from a Customer or Client?
    // ...
}

// One perspective
public interface UserAuthentication {
    boolean authenticate(String username, String password);
}

// A completely different perspective
public interface SecurityGateway {
    boolean verifyCredentials(String username, String password);
}

// Before renaming
public class OrderProcessor {
    private List<Order> orders;
    private Customer customer;
    private ShippingDetails shipping;
    private PaymentInfo payment;
    
    public void process() {
        // Complex mix of responsibilities
    }
}

// After thoughtful renaming
public class Checkout {
    private ShoppingCart cart;
    private Customer customer;
    private ShippingDetails shipping;
    private PaymentMethod paymentMethod;
    
    public Order createOrder() {
        // More focused responsibility
    }
}

// Anti-Pattern: The Monolithic Method - a confusing, cluttered story
public void processBooking(Seat seat, User user) {
    // Check if seat exists
    if (seat == null) {
        throw new IllegalArgumentException("Seat cannot be null");
    }
    
    // Check if user exists
    if (user == null) {
        throw new IllegalArgumentException("User cannot be null");
    }
    
    // Check seat availability
    if (seat.getStatus() != SeatStatus.AVAILABLE) {
        throw new SeatUnavailableException("Seat " + seat.getRow() + seat.getNumber() + " is not available");
    }
    
    // Update seat status
    seat.setStatus(SeatStatus.BOOKED);
    seatRepository.save(seat);
    
    // Create booking record
    Booking booking = new Booking();
    booking.setId(UUID.randomUUID());
    booking.setSeat(seat);
    booking.setUser(user);
    booking.setStatus(BookingStatus.CONFIRMED);
    booking.setBookingTime(LocalDateTime.now());
    bookingRepository.save(booking);
    
    // Send confirmation email
    EmailDetails email = new EmailDetails();
    email.setTo(user.getEmail());
    email.setSubject("Your booking confirmation");
    email.setBody("Your booking for seat " + seat.getRow() + seat.getNumber() + " is confirmed.");
    emailService.sendEmail(email);
    
    // Update inventory
    inventoryService.decrementAvailableSeats(seat.getScreen(), 1);
    
    // Log the transaction
    logger.info("Booking completed for user {} for seat {}{}", 
               user.getId(), seat.getRow(), seat.getNumber());
}

// Pattern: The Narrative Method - a clear, engaging story
public void processBooking(Seat seat, User user) {
    validateBookingRequest(seat, user);
    
    if (!isSeatAvailable(seat)) {
        throw new SeatUnavailableException(seat);
    }
    
    reserveSeat(seat);
    Booking booking = createBookingRecord(seat, user);
    notifyUser(booking, user);
    updateInventory(seat);
    logTransaction(booking);
}

private void validateBookingRequest(Seat seat, User user) {
    requireNonNull(seat, "Seat cannot be null");
    requireNonNull(user, "User cannot be null");
}

private boolean isSeatAvailable(Seat seat) {
    return seat.getStatus() == SeatStatus.AVAILABLE;
}

private void reserveSeat(Seat seat) {
    seat.setStatus(SeatStatus.BOOKED);
    seatRepository.save(seat);
}

private Booking createBookingRecord(Seat seat, User user) {
    Booking booking = new Booking(UUID.randomUUID(), seat, user, LocalDateTime.now());
    booking.setStatus(BookingStatus.CONFIRMED);
    bookingRepository.save(booking);
    return booking;
}

private void notifyUser(Booking booking, User user) {
    EmailDetails email = createConfirmationEmail(booking, user);
    emailService.sendEmail(email);
}

private EmailDetails createConfirmationEmail(Booking booking, User user) {
    Seat seat = booking.getSeat();
    return new EmailDetails(
        user.getEmail(),
        "Your booking confirmation",
        "Your booking for seat " + seat.getRow() + seat.getNumber() + " is confirmed."
    );
}

private void updateInventory(Seat seat) {
    inventoryService.decrementAvailableSeats(seat.getScreen(), 1);
}

private void logTransaction(Booking booking) {
    Seat seat = booking.getSeat();
    User user = booking.getUser();
    logger.info("Booking completed for user {} for seat {}{}", 
               user.getId(), seat.getRow(), seat.getNumber());
}

public void checkoutShoppingCart() {
    validateCart();
    applyDiscounts();
    calculateTotalPrice();
    processPayment();
    createOrder();
    sendConfirmation();
}

private void validateCart() {
    validateItems();
    validateCustomer();
    validateShippingAddress();
}

private void validateItems() {
    // Even more detailed implementation
}

// Command (changes state)
public void reserveSeat(Seat seat) {
    seat.setStatus(SeatStatus.RESERVED);
    seatRepository.save(seat);
}

// Query (returns information without side effects)
public boolean isSeatAvailable(Seat seat) {
    return seat.getStatus() == SeatStatus.AVAILABLE;
}

// Problematic mixed method (both changes state and returns information)
public boolean tryReserveSeat(Seat seat) {
    if (seat.getStatus() == SeatStatus.AVAILABLE) {
        seat.setStatus(SeatStatus.RESERVED);
        seatRepository.save(seat);
        return true;
    }
    return false;
}

// Inconsistent abstraction levels - like a story that randomly jumps between high-level plot and minute details
public void processOrder(Order order) {
    validateOrder(order);  // High-level
    order.setStatus(OrderStatus.PROCESSING);  // Low-level
    paymentGateway.charge(order.getTotal(), order.getPaymentMethod());  // Mid-level
    sendConfirmationEmail(order);  // High-level
}

// Consistent abstraction levels - a coherent narrative flow
public void processOrder(Order order) {
    validateOrder(order);
    updateOrderStatus(order);
    chargeCustomer(order);
    notifyCustomer(order);
}

private void updateOrderStatus(Order order) {
    order.setStatus(OrderStatus.PROCESSING);
}

private void chargeCustomer(Order order) {
    paymentGateway.charge(order.getTotal(), order.getPaymentMethod());
}

public void transferFunds(Account source, Account destination, Money amount) {
    validateTransferRequest(source, destination, amount);
    
    try {
        if (!source.hasSufficientFunds(amount)) {
            throw new InsufficientFundsException(source, amount);
        }
        
        source.withdraw(amount);
        destination.deposit(amount);
        recordTransfer(source, destination, amount);
    } catch (InsufficientFundsException e) {
        notifyInsufficientFunds(e.getAccount(), e.getAmount());
        throw e; // Rethrow for upstream handling
    } catch (AccountFrozenException e) {
        reversePartialTransfer(source, destination, amount);
        notifyAccountFrozen(e.getAccount());
        throw new TransferFailedException(e);
    }
}

// Good comment - provides context that can't be expressed in code alone
/**
 * Calculates the pricing tier based on the customer's purchase history.
 * 
 * The algorithm follows the company's 2023 loyalty program guidelines:
 * - Silver tier: $1,000+ annual spending
 * - Gold tier: $5,000+ annual spending
 * - Platinum tier: $10,000+ annual spending
 * 
 * Note: These thresholds are subject to annual review and adjustment.
 */
public PricingTier calculatePricingTier(Customer customer) {
    // Implementation
}

// Bad comment - merely repeats what the code already says clearly
// Get the customer's annual spending
Money annualSpending = customer.getAnnualSpending();

// Multiple responsibilities - the Swiss Army knife approach
public void processOrder(Order order) {
    // Validate order
    if (order == null) {
        throw new IllegalArgumentException("Order cannot be null");
    }
    if (order.getItems().isEmpty()) {
        throw new IllegalArgumentException("Order must contain at least one item");
    }
    
    // Calculate total
    Money total = Money.ZERO;
    for (OrderItem item : order.getItems()) {
        total = total.add(item.getPrice().multiply(item.getQuantity()));
    }
    
    // Apply discounts
    if (order.getCustomer().isPremium()) {
        total = total.multiply(0.9); // 10% discount for premium customers
    }
    
    // Process payment
    PaymentResult result = paymentGateway.charge(order.getPaymentMethod(), total);
    if (!result.isSuccessful()) {
        throw new PaymentFailedException(result.getErrorMessage());
    }
    
    // Update inventory
    for (OrderItem item : order.getItems()) {
        inventoryService.decrementStock(item.getProduct(), item.getQuantity());
    }
    
    // Update order status
    order.setStatus(OrderStatus.PAID);
    order.setTotalAmount(total);
    orderRepository.save(order);
    
    // Send confirmation
    emailService.sendOrderConfirmation(order);
}

// Single responsibility - the specialized tool approach
public void processOrder(Order order) {
    validateOrder(order);
    
    Money total = calculateOrderTotal(order);
    total = applyDiscounts(total, order.getCustomer());
    
    processPayment(order.getPaymentMethod(), total);
    updateInventory(order.getItems());
    updateOrderStatus(order, total);
    sendConfirmation(order);
}

private void validateOrder(Order order) {
    Objects.requireNonNull(order, "Order cannot be null");
    if (order.getItems().isEmpty()) {
        throw new IllegalArgumentException("Order must contain at least one item");
    }
}

private Money calculateOrderTotal(Order order) {
    return order.getItems().stream()
        .map(item -> item.getPrice().multiply(item.getQuantity()))
        .reduce(Money.ZERO, Money::add);
}

private Money applyDiscounts(Money total, Customer customer) {
    if (customer.isPremium()) {
        return total.multiply(0.9); // 10% discount for premium customers
    }
    return total;
}

// Additional single-responsibility methods

// Low cohesion - mixed responsibilities
public void processCustomer(Customer customer) {
    // Update customer record
    customer.setLastVisitDate(LocalDate.now());
    customerRepository.save(customer);
    
    // Generate loyalty points
    if (customer.getVisitCount() > 10) {
        LoyaltyPoints points = new LoyaltyPoints(customer, 100);
        loyaltyRepository.save(points);
    }
    
    // Send marketing email if subscribed
    if (customer.isSubscribedToMarketing()) {
        Email marketingEmail = new Email(
            customer.getEmail(),
            "Special Offers Just For You",
            marketingTemplateGenerator.generate(customer)
        );
        emailService.send(marketingEmail);
    }
}

// High cohesion - focused responsibility
public void recordCustomerVisit(Customer customer) {
    customer.setLastVisitDate(LocalDate.now());
    customer.incrementVisitCount();
    customerRepository.save(customer);
}

public void processLoyaltyPoints(Customer customer) {
    if (customer.getVisitCount() > 10) {
        LoyaltyPoints points = new LoyaltyPoints(customer, 100);
        loyaltyRepository.save(points);
    }
}

public void sendMarketingEmailIfSubscribed(Customer customer) {
    if (customer.isSubscribedToMarketing()) {
        Email marketingEmail = new Email(
            customer.getEmail(),
            "Special Offers Just For You",
            marketingTemplateGenerator.generate(customer)
        );
        emailService.send(marketingEmail);
    }
}

public void processCustomer(Customer customer) {
    recordCustomerVisit(customer);
    processLoyaltyPoints(customer);
    sendMarketingEmailIfSubscribed(customer);
}

// Glue method that composes focused, single-responsibility methods
public void checkoutShoppingCart(ShoppingCart cart, Customer customer, PaymentMethod paymentMethod) {
    validateCheckoutPreconditions(cart, customer, paymentMethod);
    
    Order order = createOrderFromCart(cart, customer);
    Money total = calculateOrderTotal(order);
    applyDiscountsAndPromotions(order, customer);
    
    processPayment(order, paymentMethod);
    fulfillOrder(order);
    notifyCustomer(order, customer);
    updateInventory(order);
}

// Humble method pattern
public Order createOrder(Customer customer, List<OrderItem> items) {
    validateOrderCreation(customer, items);
    Order order = orderFactory.createOrder(customer, items);
    enrichOrderWithMetadata(order);
    trackOrderCreation(order);
    return order;
}

// Transformation chain pattern
public Report generateMonthlyReport(Month month, Year year) {
    List<Transaction> transactions = fetchTransactionsForPeriod(month, year);
    List<Transaction> validTransactions = filterValidTransactions(transactions);
    Map<Category, List<Transaction>> categorizedTransactions = categorizeTransactions(validTransactions);
    Map<Category, Money> categoryTotals = calculateCategoryTotals(categorizedTransactions);
    Report report = createReportFromTotals(categoryTotals, month, year);
    return report;
}

// Violates SRP - answers to multiple authorities
public class Patient {
    private final UUID id;
    private final String name;
    private final LocalDate dateOfBirth;
    private List<Prescription> prescriptions;
    private Insurance insurance;
    private BillingAccount billingAccount;
    
    public void prescribeMedication(Medication medication, Doctor doctor) {
        // Prescription logic
    }
    
    public void generateBill() {
        // Billing logic
    }
    
    public void processInsuranceClaim() {
        // Insurance claim logic
    }
}

// Respects SRP - clear authority boundaries
public class Patient {
    private final UUID id;
    private final String name;
    private final LocalDate dateOfBirth;
    private List<Prescription> prescriptions;
    
    public void addPrescription(Prescription prescription) {
        prescriptions.add(prescription);
    }
}

public class PrescriptionService {
    public Prescription createPrescription(Patient patient, Medication medication, Doctor doctor) {
        // Prescription logic under medical authority
    }
}

public class BillingService {
    public Bill generateBill(Patient patient, List<Treatment> treatments) {
        // Billing logic under financial authority
    }
}

public class InsuranceService {
    public Claim processInsuranceClaim(Patient patient, Bill bill) {
        // Insurance logic under insurance authority
    }
}

// Violates OCP - requires modification for new types
public class PaymentProcessor {
    public void processPayment(Order order) {
        switch (order.getPaymentMethod().getType()) {
            case "CREDIT_CARD":
                processCreditCardPayment(order);
                break;
            case "PAYPAL":
                processPayPalPayment(order);
                break;
            // Adding a new payment method requires modifying this class
        }
    }
}

// Respects OCP - extends through new implementations
public interface PaymentMethod {
    void processPayment(Order order);
}

public class CreditCardPayment implements PaymentMethod {
    @Override
    public void processPayment(Order order) {
        // Credit card payment logic
    }
}

public class PayPalPayment implements PaymentMethod {
    @Override
    public void processPayment(Order order) {
        // PayPal payment logic
    }
}

// Adding a new payment method just requires a new implementation
public class CryptoCurrencyPayment implements PaymentMethod {
    @Override
    public void processPayment(Order order) {
        // Cryptocurrency payment logic
    }
}

public class PaymentProcessor {
    public void processPayment(Order order) {
        order.getPaymentMethod().processPayment(order);
    }
}

// Violates LSP - breaks the promise of the base class
public class Rectangle {
    protected int width;
    protected int height;
    
    public void setWidth(int width) {
        this.width = width;
    }
    
    public void setHeight(int height) {
        this.height = height;
    }
    
    public int getArea() {
        return width * height;
    }
}

public class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        this.width = width;
        this.height = width; // Breaks the promise of setWidth
    }
    
    @Override
    public void setHeight(int height) {
        this.width = height; // Breaks the promise of setHeight
        this.height = height;
    }
}

// Client code that breaks with Square
public void resizeRectangle(Rectangle rectangle) {
    rectangle.setWidth(10);
    rectangle.setHeight(20);
    assert rectangle.getArea() == 200; // Fails with Square
}

// Respects LSP - clear behavioral contracts
public interface Shape {
    int getArea();
}

public class Rectangle implements Shape {
    private int width;
    private int height;
    
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
    
    public void setWidth(int width) {
        this.width = width;
    }
    
    public void setHeight(int height) {
        this.height = height;
    }
    
    @Override
    public int getArea() {
        return width * height;
    }
}

public class Square implements Shape {
    private int side;
    
    public Square(int side) {
        this.side = side;
    }
    
    public void setSide(int side) {
        this.side = side;
    }
    
    @Override
    public int getArea() {
        return side * side;
    }
}

// Violates ISP - forces implementations to handle methods they don't need
public interface Employee {
    void work();
    void takeBreak();
    void receivePayment();
    void attendMeeting();
    void performAdminTasks();
    void manageTeam();
}

// Contract forces all implementations to define all methods
public class Developer implements Employee {
    @Override
    public void work() { /* Implementation */ }
    
    @Override
    public void takeBreak() { /* Implementation */ }
    
    @Override
    public void receivePayment() { /* Implementation */ }
    
    @Override
    public void attendMeeting() { /* Implementation */ }
    
    @Override
    public void performAdminTasks() {
        // Empty - developers don't perform admin tasks
    }
    
    @Override
    public void manageTeam() {
        // Empty - developers don't manage teams
    }
}

// Respects ISP - focused, consensual contracts
public interface Worker {
    void work();
    void takeBreak();
}

public interface Payable {
    void receivePayment();
}

public interface TeamMember {
    void attendMeeting();
}

public interface Administrator {
    void performAdminTasks();
}

public interface Manager {
    void manageTeam();
}

// Classes only implement the interfaces that align with their roles
public class Developer implements Worker, Payable, TeamMember {
    @Override
    public void work() { /* Implementation */ }
    
    @Override
    public void takeBreak() { /* Implementation */ }
    
    @Override
    public void receivePayment() { /* Implementation */ }
    
    @Override
    public void attendMeeting() { /* Implementation */ }
}

public class TeamLead implements Worker, Payable, TeamMember, Manager {
    // Implements only relevant interfaces
}

// Violates DIP - high-level policy depends on low-level details
public class OrderService {
    private MySQLOrderRepository orderRepository;
    private StripePaymentProcessor paymentProcessor;
    
    public OrderService() {
        this.orderRepository = new MySQLOrderRepository();
        this.paymentProcessor = new StripePaymentProcessor();
    }
    
    public void placeOrder(Order order) {
        paymentProcessor.processPayment(order);
        orderRepository.save(order);
    }
}

// Respects DIP - respecting conceptual superiority
public interface OrderRepository {
    void save(Order order);
}

public interface PaymentProcessor {
    void processPayment(Order order);
}

public class OrderService {
    private final OrderRepository orderRepository;
    private final PaymentProcessor paymentProcessor;
    
    public OrderService(OrderRepository orderRepository, PaymentProcessor paymentProcessor) {
        this.orderRepository = orderRepository;
        this.paymentProcessor = paymentProcessor;
    }
    
    public void placeOrder(Order order) {
        paymentProcessor.processPayment(order);
        orderRepository.save(order);
    }
}

// Implementations serve the abstractions
public class MySQLOrderRepository implements OrderRepository {
    @Override
    public void save(Order order) {
        // MySQL implementation
    }
}

public class StripePaymentProcessor implements PaymentProcessor {
    @Override
    public void processPayment(Order order) {
        // Stripe implementation
    }
}

public final class String implements Comparable<String>, CharSequence {
    private final char[] value; // The actual characters, private and final
    
    // Methods like substring() create NEW String instances
    public String substring(int beginIndex, int endIndex) {
        // Returns new String, doesn't modify this one
    }
}

public interface Collection<E> extends Iterable<E> {
    // Basic operations
    boolean add(E e);
    boolean remove(Object o);
    boolean contains(Object o);
    
    // Bulk operations
    boolean addAll(Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    boolean retainAll(Collection<?> c);
    
    // Other methods...
}

public interface List<E> extends Collection<E> {
    // List-specific methods
    E get(int index);
    E set(int index, E element);
    void add(int index, E element);
    E remove(int index);
    // Other methods...
}

public interface Set<E> extends Collection<E> {
    // No additional methods - semantics differ
}

public interface Map<K, V> {
    // Map-specific methods
    V get(Object key);
    V put(K key, V value);
    V remove(Object key);
    // Other methods...
}

public class Object {
    public boolean equals(Object obj) {
        return this == obj;
    }
    
    public int hashCode() {
        // Native method that returns identity hash code
    }
    
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
    
    // Other methods...
}

// Natural ordering through Comparable
public class Person implements Comparable<Person> {
    private final String lastName;
    private final String firstName;
    
    @Override
    public int compareTo(Person other) {
        // Natural order: last name, then first name
        int lastNameComparison = this.lastName.compareTo(other.lastName);
        if (lastNameComparison != 0) {
            return lastNameComparison;
        }
        return this.firstName.compareTo(other.firstName);
    }
}

// External ordering through Comparator
public class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return Integer.compare(p1.getAge(), p2.getAge());
    }
}

public class Throwable {
    // Base class for all errors and exceptions
}

public class Error extends Throwable {
    // Serious problems that normal applications should not catch
}

public class Exception extends Throwable {
    // Conditions that a reasonable application might want to catch
}

public class RuntimeException extends Exception {
    // Exceptions that can occur during normal program execution
}

// Type parameterization
public class Box<T> {
    private T content;
    
    public void put(T item) {
        this.content = item;
    }
    
    public T get() {
        return content;
    }
}

// Bounded type parameters
public class NumberBox<T extends Number> {
    private T content;
    
    public void put(T item) {
        this.content = item;
    }
    
    public T get() {
        return content;
    }
    
    public double getDoubleValue() {
        return content.doubleValue(); // Safe because T extends Number
    }
}

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

List<Person> adults = persons.stream()
    .filter(person -> person.getAge() >= 18)
    .sorted(Comparator.comparing(Person::getLastName))
    .collect(Collectors.toList());

@Test
public void movieTitleCannotBeChanged() {
    Movie movie = new Movie("The Godfather", LocalDate.of(1972, 3, 24), Set.of(MovieGenre.DRAMA));
    
    // Verify no setter exists
    assertFalse(Arrays.stream(Movie.class.getMethods())
                    .anyMatch(method -> method.getName().equals("setTitle")));
    
    // Try to access private field using reflection (should fail)
    assertThrows(IllegalAccessException.class, () -> {
        Field titleField = Movie.class.getDeclaredField("title");
        titleField.setAccessible(true);
        titleField.set(movie, "Changed Title");
    });
}

@Test
public void actorRemunerationIsOnlyVisibleToAuthorizedParties() {
    Actor actor = new Actor("John", "Doe", LocalDate.of(1980, 1, 1), Gender.MALE, new BigDecimal("1000000"));
    Agent authorizedAgent = new Agent("Jane", "Smith");
    Agent unauthorizedAgent = new Agent("Bob", "Johnson");
    
    // Establish relationship with authorized agent
    actor.setAgent(authorizedAgent);
    
    // Authorized agent can access remuneration
    assertEquals(new BigDecimal("1000000"), actor.getRemunerationForAgent(authorizedAgent));
    
    // Unauthorized agent cannot access remuneration
    assertThrows(UnauthorizedAccessException.class, () -> {
        actor.getRemunerationForAgent(unauthorizedAgent);
    });
}

@Test
public void bankAccountBalanceNeverNegative() {
    BankAccount account = new BankAccount("123456", new Money(BigDecimal.valueOf(100), Currency.USD));
    
    // Successful withdrawal
    assertTrue(account.withdraw(new Money(BigDecimal.valueOf(50), Currency.USD)));
    assertEquals(new Money(BigDecimal.valueOf(50), Currency.USD), account.getBalance());
    
    // Attempt to withdraw more than balance
    assertFalse(account.withdraw(new Money(BigDecimal.valueOf(100), Currency.USD)));
    assertEquals(new Money(BigDecimal.valueOf(50), Currency.USD), account.getBalance());
    
    // Balance should never be negative
    Field balanceField = BankAccount.class.getDeclaredField("balance");
    balanceField.setAccessible(true);
    Money balance = (Money) balanceField.get(account);
    assertTrue(balance.getAmount().compareTo(BigDecimal.ZERO) >= 0);
}

@Test
public void seatCannotBeBookedTwice() {
    Seat seat = new Seat('A', 1, SeatType.STANDARD);
    
    // First booking succeeds
    assertTrue(seat.book());
    assertEquals(SeatStatus.BOOKED, seat.getStatus());
    
    // Second booking fails
    assertFalse(seat.book());
    assertEquals(SeatStatus.BOOKED, seat.getStatus());
}

@Test
public void concurrentSeatReservationMaintainsConsistency() throws InterruptedException {
    ShowTime showTime = createShowTimeWithAvailableSeats();
    SeatCoordinate seat = new SeatCoordinate('A', 1);
    
    // Create countdown latch for synchronization
    CountDownLatch startLatch = new CountDownLatch(1);
    CountDownLatch finishLatch = new CountDownLatch(2);
    
    // Results for each thread
    AtomicBoolean result1 = new AtomicBoolean();
    AtomicBoolean result2 = new AtomicBoolean();
    
    // Create two threads trying to book the same seat
    Thread thread1 = new Thread(() -> {
        try {
            startLatch.await(); // Wait for start signal
            result1.set(showTime.reserveSeat(seat));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            finishLatch.countDown();
        }
    });
    
    Thread thread2 = new Thread(() -> {
        try {
            startLatch.await(); // Wait for start signal
            result2.set(showTime.reserveSeat(seat));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            finishLatch.countDown();
        }
    });
    
    // Start threads
    thread1.start();
    thread2.start();
    startLatch.countDown(); // Signal threads to start
    finishLatch.await(); // Wait for both threads to finish
    
    // Verify only one thread succeeded
    assertTrue(result1.get() ^ result2.get(), "Only one thread should succeed");
    assertEquals(SeatStatus.RESERVED, showTime.getSeatStatus(seat), "Seat should be reserved");
}

@Test
public void premiumUserCanBeUsedWhereUserIsExpected() {
    User regularUser = new RegularUser("user1", "password", "John", "Doe");
    User premiumUser = new PremiumUser("user2", "password", "Jane", "Smith", PremiumLevel.GOLD);
    
    UserService userService = new UserService();
    
    // Both user types should work with the service
    assertEquals("John Doe", userService.getFullName(regularUser));
    assertEquals("Jane Smith", userService.getFullName(premiumUser));
    
    // Premium user should maintain its special capabilities
    assertTrue(premiumUser instanceof PremiumUser);
    assertEquals(PremiumLevel.GOLD, ((PremiumUser) premiumUser).getPremiumLevel());
}

@Test
public void personNameIsImmutablePartOfIdentity() {
    // Arrange
    Person person = new Person("John", "Doe", LocalDate.of(1980, 1, 1), Gender.MALE);
    
    // Act & Assert - no method exists to change the name
    assertFalse(Arrays.stream(Person.class.getMethods())
                    .anyMatch(method -> method.getName().equals("setFirstName")));
    assertFalse(Arrays.stream(Person.class.getMethods())
                    .anyMatch(method -> method.getName().equals("setLastName")));
    
    // Assert that we can still access the name
    assertEquals("John", person.getFirstName());
    assertEquals("Doe", person.getLastName());
}

/**
 * Represents a Movie in the cinema system.
 * 
 * As a Movie, my identity consists of my title, release date, and duration.
 * These attributes are immutable because they define what movie I am.
 * 
 * As a Movie, I own my cast and crew lists. These collections are part of
 * what makes me the specific movie that I am, though they may be amended
 * with additional information over time.
 * 
 * As a Movie, I know my genres and can answer questions about my content
 * and audience suitability.
 */
public final class Movie {
    private final UUID id;
    private final String title; // Immutable - defines identity
    private final int durationMinutes; // Immutable
    private final LocalDate releaseDate; // Immutable
    private final Set<MovieGenre> genres; // Immutable set of enum values
    private final String synopsis;
    private final Set<CastMember> cast; // Immutable collection
    private final Set<CrewMember> crew; // Immutable collection
    
    // Constructor with validation
    public Movie(String title, int durationMinutes, LocalDate releaseDate, 
                 Set<MovieGenre> genres, String synopsis, 
                 Set<CastMember> cast, Set<CrewMember> crew) {
        this.id = UUID.randomUUID();
        this.title = Objects.requireNonNull(title, "Title cannot be null");
        
        if (durationMinutes <= 0) {
            throw new IllegalArgumentException("Duration must be positive");
        }
        this.durationMinutes = durationMinutes;
        
        this.releaseDate = Objects.requireNonNull(releaseDate, "Release date cannot be null");
        
        // Defensive copy of collections
        this.genres = Collections.unmodifiableSet(new HashSet<>(
            Objects.requireNonNull(genres, "Genres cannot be null")));
        
        this.synopsis = synopsis; // Can be null
        
        this.cast = Collections.unmodifiableSet(new HashSet<>(
            Objects.requireNonNull(cast, "Cast cannot be null")));
            
        this.crew = Collections.unmodifiableSet(new HashSet<>(
            Objects.requireNonNull(crew, "Crew cannot be null")));
    }
    
    // No setters for identity attributes
    
    // Getters with appropriate access control
    public UUID getId() {
        return id;
    }
    
    public String getTitle() {
        return title;
    }
    
    public int getDurationMinutes() {
        return durationMinutes;
    }
    
    public LocalDate getReleaseDate() {
        return releaseDate;
    }
    
    public Set<MovieGenre> getGenres() {
        return genres; // Already immutable
    }
    
    public String getSynopsis() {
        return synopsis;
    }
    
    public Set<CastMember> getCast() {
        return cast; // Already immutable
    }
    
    public Set<CrewMember> getCrew() {
        return crew; // Already immutable
    }
    
    // Domain methods
    public boolean isOfGenre(MovieGenre genre) {
        return genres.contains(genre);
    }
    
    public boolean isSuitableForChildren() {
        return !genres.contains(MovieGenre.HORROR) && 
               !genres.contains(MovieGenre.THRILLER);
    }
    
    public boolean hasCastMember(Person person) {
        return cast.stream()
            .anyMatch(member -> member.getPerson().equals(person));
    }
    
    public boolean hasDirector(Person person) {
        return crew.stream()
            .anyMatch(member -> member.getRole() == CrewRole.DIRECTOR && 
                     member.getPerson().equals(person));
    }
    
    // Object methods implementation
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        
        Movie movie = (Movie) o;
        
        return title.equals(movie.title) && 
               releaseDate.equals(movie.releaseDate);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(title, releaseDate);
    }
    
    @Override
    public String toString() {
        return String.format("Movie: %s (%s)", title, releaseDate.getYear());
    }
}

/**
 * Represents a Person in the movie domain.
 * 
 * As a Person, my name and date of birth define my identity and cannot be changed.
 * As a Person, my gender is an intrinsic property represented as an enum, not a string.
 * As a Person, I control access to my remuneration information, sharing it only
 * with authorized parties like my agent or tax authorities.
 */
public class Person {
    private final UUID id;
    private final String firstName; // Immutable
    private final String lastName; // Immutable
    private final LocalDate dateOfBirth; // Immutable
    private final Gender gender; // Enum type, not String
    private final BigDecimal remuneration; // Private with controlled access
    private ContactInformation contactInfo; // Controlled access
    
    // Constructor with validation
    public Person(String firstName, String lastName, LocalDate dateOfBirth, Gender gender) {
        this(firstName, lastName, dateOfBirth, gender, null);
    }
    
    public Person(String firstName, String lastName, LocalDate dateOfBirth, 
                  Gender gender, BigDecimal remuneration) {
        this.id = UUID.randomUUID();
        this.firstName = Objects.requireNonNull(firstName, "First name cannot be null");
        this.lastName = Objects.requireNonNull(lastName, "Last name cannot be null");
        this.dateOfBirth = Objects.requireNonNull(dateOfBirth, "Date of birth cannot be null");
        this.gender = Objects.requireNonNull(gender, "Gender cannot be null");
        this.remuneration = remuneration; // Can be null
    }
    
    // No setter for name - "My name is my identity"
    
    // Getters for identity attributes
    public UUID getId() {
        return id;
    }
    
    public String getFirstName() {
        return firstName;
    }
    
    public String getLastName() {
        return lastName;
    }
    
    public String getFullName() {
        return firstName + " " + lastName;
    }
    
    public LocalDate getDateOfBirth() {
        return dateOfBirth;
    }
    
    public Gender getGender() {
        return gender;
    }
    
    // Controlled access to remuneration
    public BigDecimal getRemunerationForAgent(Agent agent) {
        if (this.isRepresentedBy(agent)) {
            return this.remuneration;
        }
        throw new UnauthorizedAccessException("You are not my agent");
    }
    
    public BigDecimal getRemunerationForTaxAuthority(TaxAuthority authority) {
        if (authority.hasJurisdictionOver(this)) {
            return this.remuneration;
        }
        throw new UnauthorizedAccessException("You have no jurisdiction over me");
    }
    
    // No public getter for remuneration
    
    // Controlled access to contact information
    public void updateContactInformation(ContactInformation contactInfo) {
        this.contactInfo = Objects.requireNonNull(contactInfo, "Contact info cannot be null");
    }
    
    public ContactInformation getContactInfoFor(Entity requestor) {
        if (isAuthorizedFor(requestor, AccessLevel.CONTACT_INFO)) {
            return contactInfo == null ? null : new ContactInformation(contactInfo); // Return defensive copy
        }
        throw new UnauthorizedAccessException("Not authorized to access contact information");
    }
    
    // Helper methods
    private boolean isRepresentedBy(Agent agent) {
        // Implementation
        return agent != null && agent.representsClient(this);
    }
    
    private boolean isAuthorizedFor(Entity requestor, AccessLevel level) {
        // Implementation based on relationship and access level
        return requestor != null && (requestor instanceof Agent && isRepresentedBy((Agent) requestor));
    }
    
    // Object methods implementation
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        
        Person person = (Person) o;
        
        return firstName.equals(person.firstName) && 
               lastName.equals(person.lastName) && 
               dateOfBirth.equals(person.dateOfBirth);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(firstName, lastName, dateOfBirth);
    }
    
    @Override
    public String toString() {
        return String.format("%s %s", firstName, lastName);
    }
}

/**
 * Represents a Theatre in the cinema system.
 * 
 * As a Theatre, my name and location define my identity and cannot be changed.
 * As a Theatre, I consist of multiple screens, which are part of my physical structure.
 * As a Theatre, I define what seat types exist in my space through my own type registry.
 */
public final class Theatre {
    private final UUID id;
    private final String name; // Immutable
    private final Address location; // Immutable value object
    private final Set<Screen> screens; // Immutable collection
    private final SeatTypeRegistry seatTypes; // Theatre-specific seat types
    
    // Constructor with validation
    public Theatre(String name, Address location, Set<Screen> screens) {
        this.id = UUID.randomUUID();
        this.name = Objects.requireNonNull(name, "Name cannot be null");
        this.location = Objects.requireNonNull(location, "Location cannot be null");
        
        // Defensive copy
        this.screens = Collections.unmodifiableSet(new HashSet<>(
            Objects.requireNonNull(screens, "Screens cannot be null")));
            
        this.seatTypes = new SeatTypeRegistry();
        initializeDefaultSeatTypes();
    }
    
    // Theatre defines its own seat types
    private void initializeDefaultSeatTypes() {
        seatTypes.registerType("STD", "Standard", new BigDecimal("1.0"));
        seatTypes.registerType("PRM", "Premium", new BigDecimal("1.5"));
        seatTypes.registerType("VIP", "VIP", new BigDecimal("2.0"));
    }
    
    // No setters for identity attributes
    
    // Getters
    public UUID getId() {
        return id;
    }
    
    public String getName() {
        return name;
    }
    
    public Address getLocation() {
        return location;
    }
    
    public Set<Screen> getScreens() {
        return screens; // Already immutable
    }
    
    // Access to seat type registry
    public SeatType getSeatType(String code) {
        return seatTypes.getType(code);
    }
    
    public void registerSeatType(String code, String name, BigDecimal priceMultiplier) {
        seatTypes.registerType(code, name, priceMultiplier);
    }
    
    // Domain methods
    public Optional<Screen> findScreenByName(String screenName) {
        return screens.stream()
            .filter(screen -> screen.getName().equals(screenName))
            .findFirst();
    }
    
    // Object methods implementation
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        
        Theatre theatre = (Theatre) o;
        
        return name.equals(theatre.name) && 
               location.equals(theatre.location);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, location);
    }
    
    @Override
    public String toString() {
        return String.format("Theatre: %s at %s", name, location);
    }
}

/**
 * Represents a Seat in a theatre screen.
 * 
 * As a Seat, my row, number, and type define my physical identity and cannot be changed.
 * As a Seat, my status can change, but only through valid transitions.
 * As a Seat, I protect my state during concurrent operations through thread safety.
 */
public final class Seat {
    private final char row; // Immutable
    private final int seatNumber; // Immutable
    private final SeatType type; // Immutable
    private SeatStatus status; // Mutable with controlled transitions
    
    // Constructor with validation
    public Seat(char row, int seatNumber, SeatType type) {
        if (!Character.isLetter(row)) {
            throw new IllegalArgumentException("Row must be a letter");
        }
        this.row = Character.toUpperCase(row);
        
        if (seatNumber <= 0) {
            throw new IllegalArgumentException("Seat number must be positive");
        }
        this.seatNumber = seatNumber;
        
        this.type = Objects.requireNonNull(type, "Type cannot be null");
        this.status = SeatStatus.AVAILABLE;
    }
    
    // No setters for immutable properties
    
    // Getters
    public char getRow() {
        return row;
    }
    
    public int getSeatNumber() {
        return seatNumber;
    }
    
    public SeatType getType() {
        return type;
    }
    
    public SeatStatus getStatus() {
        return status;
    }
    
    // Thread-safe state transitions
    public synchronized boolean reserve() {
        if (status != SeatStatus.AVAILABLE) {
            return false;
        }
        status = SeatStatus.RESERVED;
        return true;
    }
    
    public synchronized boolean book() {
        if (status != SeatStatus.RESERVED) {
            return false;
        }
        status = SeatStatus.BOOKED;
        return true;
    }
    
    public synchronized boolean release() {
        if (status != SeatStatus.RESERVED) {
            return false;
        }
        status = SeatStatus.AVAILABLE;
        return true;
    }
    
    public synchronized boolean block() {
        if (status == SeatStatus.RESERVED || status == SeatStatus.BOOKED) {
            return false;
        }
        status = SeatStatus.BLOCKED_FOR_MAINTENANCE;
        return true;
    }
    
    public synchronized boolean unblock() {
        if (status != SeatStatus.BLOCKED_FOR_MAINTENANCE) {
            return false;
        }
        status = SeatStatus.AVAILABLE;
        return true;
    }
    
    // Domain methods
    public String getDisplayName() {
        return String.format("%c%d", row, seatNumber);
    }
    
    // Object methods implementation
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        
        Seat seat = (Seat) o;
        
        return row == seat.row && 
               seatNumber == seat.seatNumber && 
               type.equals(seat.type);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(row, seatNumber, type);
    }
    
    @Override
    public String toString() {
        return String.format("Seat %c%d (%s)", row, seatNumber, status);
    }
}

/**
 * Represents a ShowTime - a specific screening of a movie at a specific time and screen.
 * 
 * As a ShowTime, my movie, screen, and start time define my identity and cannot be changed.
 * As a ShowTime, I control the booking of my seats and maintain their status.
 * As a ShowTime, I ensure thread safety for concurrent seat operations.
 */
public final class ShowTime {
    private final UUID id;
    private final Movie movie; // Immutable reference
    private final Screen screen; // Immutable reference
    private final LocalDateTime startTime; // Immutable
    private final Map<SeatCoordinate, SeatStatus> seatStatusMap; // Mutable with controlled access
    
    // Constructor with validation
    public ShowTime(Movie movie, Screen screen, LocalDateTime startTime) {
        this.id = UUID.randomUUID();
        this.movie = Objects.requireNonNull(movie, "Movie cannot be null");
        this.screen = Objects.requireNonNull(screen, "Screen cannot be null");
        this.startTime = Objects.requireNonNull(startTime, "Start time cannot be null");
        
        // Initialize all seats as available
        this.seatStatusMap = new ConcurrentHashMap<>();
        initializeSeatStatus();
    }
    
    private void initializeSeatStatus() {
        for (Seat seat : screen.getSeatLayout().getSeats()) {
            seatStatusMap.put(
                new SeatCoordinate(seat.getRow(), seat.getSeatNumber()),
                SeatStatus.AVAILABLE
            );
        }
    }
    
    // No setters for immutable properties
    
    // Getters
    public UUID getId() {
        return id;
    }
    
    public Movie getMovie() {
        return movie;
    }
    
    public Screen getScreen() {
        return screen;
    }
    
    public LocalDateTime getStartTime() {
        return startTime;
    }
    
    public LocalDateTime getEndTime() {
        return startTime.plusMinutes(movie.getDurationMinutes());
    }
    
    // Seat status operations
    public SeatStatus getSeatStatus(SeatCoordinate coordinate) {
        validateSeatCoordinate(coordinate);
        return seatStatusMap.get(coordinate);
    }
    
    public synchronized boolean reserveSeat(SeatCoordinate coordinate) {
        validateSeatCoordinate(coordinate);
        
        SeatStatus currentStatus = seatStatusMap.get(coordinate);
        if (currentStatus != SeatStatus.AVAILABLE) {
            return false;
        }
        
        seatStatusMap.put(coordinate, SeatStatus.RESERVED);
        return true;
    }
    
    public synchronized boolean bookSeat(SeatCoordinate coordinate) {
        validateSeatCoordinate(coordinate);
        
        SeatStatus currentStatus = seatStatusMap.get(coordinate);
        if (currentStatus != SeatStatus.RESERVED) {
            return false;
        }
        
        seatStatusMap.put(coordinate, SeatStatus.BOOKED);
        return true;
    }
    
    public synchronized boolean releaseSeat(SeatCoordinate coordinate) {
        validateSeatCoordinate(coordinate);
        
        SeatStatus currentStatus = seatStatusMap.get(coordinate);
        if (currentStatus != SeatStatus.RESERVED) {
            return false;
        }
        
        seatStatusMap.put(coordinate, SeatStatus.AVAILABLE);
        return true;
    }
    
    // Helper method to validate seat coordinates
    private void validateSeatCoordinate(SeatCoordinate coordinate) {
        Objects.requireNonNull(coordinate, "Seat coordinate cannot be null");
        
        if (!seatStatusMap.containsKey(coordinate)) {
            throw new IllegalArgumentException("Invalid seat coordinate: " + coordinate);
        }
    }
    
    // Domain methods
    public boolean areAllSeatsAvailable(Set<SeatCoordinate> coordinates) {
        for (SeatCoordinate coordinate : coordinates) {
            if (getSeatStatus(coordinate) != SeatStatus.AVAILABLE) {
                return false;
            }
        }
        return true;
    }
    
    public synchronized boolean reserveSeats(Set<SeatCoordinate> coordinates) {
        // First check if all seats are available
        if (!areAllSeatsAvailable(coordinates)) {
            return false;
        }
        
        // Then reserve all seats
        for (SeatCoordinate coordinate : coordinates) {
            seatStatusMap.put(coordinate, SeatStatus.RESERVED);
        }
        
        return true;
    }
    
    public Map<SeatCoordinate, SeatStatus> getSeatStatusSnapshot() {
        return new HashMap<>(seatStatusMap);
    }
    
    // Object methods implementation
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        
        ShowTime showTime = (ShowTime) o;
        
        return movie.equals(showTime.movie) && 
               screen.equals(showTime.screen) && 
               startTime.equals(showTime.startTime);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(movie, screen, startTime);
    }
    
    @Override
    public String toString() {
        return String.format("%s at %s on %s", 
            movie.getTitle(), 
            screen.getName(), 
            startTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")));
    }
}

/**
 * Represents a Booking for seats at a specific show time.
 * 
 * As a Booking, my show time, seats, and user define my core identity.
 * As a Booking, my status changes through a well-defined workflow.
 * As a Booking, I know when I was created and can enforce timeout rules.
 */
public final class Booking {
    private final UUID id;
    private final ShowTime showTime; // Immutable reference
    private final Set<SeatCoordinate> seats; // Immutable after creation
    private final User user; // Immutable reference
    private final LocalDateTime bookingTime; // Immutable
    private BookingStatus status; // Mutable with controlled transitions
    
    // Constructor with validation
    public Booking(ShowTime showTime, Set<SeatCoordinate> seats, User user) {
        this.id = UUID.randomUUID();
        this.showTime = Objects.requireNonNull(showTime, "Show time cannot be null");
        
        // Defensive copy
        this.seats = Collections.unmodifiableSet(new HashSet<>(
            Objects.requireNonNull(seats, "Seats cannot be null")));
            
        if (seats.isEmpty()) {
            throw new IllegalArgumentException("Seats cannot be empty");
        }
        
        this.user = Objects.requireNonNull(user, "User cannot be null");
        this.bookingTime = LocalDateTime.now();
        this.status = BookingStatus.INITIATED;
    }
    
    // No setters for immutable properties
    
    // Getters
    public UUID getId() {
        return id;
    }
    
    public ShowTime getShowTime() {
        return showTime;
    }
    
    public Set<SeatCoordinate> getSeats() {
        return seats; // Already immutable
    }
    
    public User getUser() {
        return user;
    }
    
    public LocalDateTime getBookingTime() {
        return bookingTime;
    }
    
    public BookingStatus getStatus() {
        return status;
    }
    
    // Controlled state transitions
    public boolean markPaymentPending() {
        if (status != BookingStatus.INITIATED) {
            return false;
        }
        status = BookingStatus.PAYMENT_PENDING;
        return true;
    }
    
    public boolean confirm() {
        if (status != BookingStatus.PAYMENT_PENDING) {
            return false;
        }
        status = BookingStatus.CONFIRMED;
        return true;
    }
    
    public boolean cancel() {
        if (status == BookingStatus.COMPLETED || status == BookingStatus.CANCELLED) {
            return false;
        }
        status = BookingStatus.CANCELLED;
        return true;
    }
    
    public boolean complete() {
        if (status != BookingStatus.CONFIRMED) {
            return false;
        }
        status = BookingStatus.COMPLETED;
        return true;
    }
    
    // Domain methods
    public boolean isExpired(int expirationMinutes) {
        return status == BookingStatus.INITIATED || status == BookingStatus.PAYMENT_PENDING ? 
               bookingTime.plusMinutes(expirationMinutes).isBefore(LocalDateTime.now()) :
               false;
    }
    
    public int getNumberOfSeats() {
        return seats.size();
    }
    
    // Object methods implementation
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        
        Booking booking = (Booking) o;
        
        return id.equals(booking.id);
    }
    
    @Override
    public int hashCode() {
        return id.hashCode();
    }
    
    @Override
    public String toString() {
        return String.format("Booking %s for %s by %s (%s)", 
            id.toString().substring(0, 8), 
            showTime, 
            user.getUsername(), 
            status);
    }
}

/**
 * Presentation Layer - Command Line Interface (Phase 1)
 * Enforces domain constraints at the input level.
 */
public class MoviePresentation {
    private final MovieService movieService;
    
    // Constructor with dependency injection
    public MoviePresentation(MovieService movieService) {
        this.movieService = Objects.requireNonNull(movieService);
    }
    
    public void displayGenreSelectionMenu() {
        System.out.println("Select movie genre:");
        
        // Present enum values in user-friendly format
        MovieGenre[] genres = MovieGenre.values();
        for (int i = 0; i < genres.length; i++) {
            System.out.printf("%d. %s%n", i + 1, formatEnumForDisplay(genres[i]));
        }
    }
    
    // Convert user input to proper enum
    public MovieGenre getSelectedGenre(int selection) {
        MovieGenre[] genres = MovieGenre.values();
        if (selection < 1 || selection > genres.length) {
            throw new IllegalArgumentException("Invalid genre selection");
        }
        return genres[selection - 1];
    }
    
    // Format enum for display
    private String formatEnumForDisplay(MovieGenre genre) {
        // Convert SCIENCE_FICTION to "Science Fiction"
        return Arrays.stream(genre.name().split("_"))
            .map(word -> word.charAt(0) + word.substring(1).toLowerCase())
            .collect(Collectors.joining(" "));
    }
    
    // Other presentation methods
}

/**
 * Service Layer - Natural Authority Boundaries
 * Each service controls access to its domain objects and enforces domain rules.
 */
public interface BookingService {
    // Atomic operation for seat reservation
    ReservationResult reserveSeats(ShowTime showTime, Set<SeatCoordinate> seats, User user);
    
    // Controlled state transition
    boolean confirmBooking(UUID bookingId, PaymentDetails paymentDetails);
    
    // Authority-based cancellation
    boolean cancelBooking(UUID bookingId, User user);
}

```java
public class BookingServiceImpl implements BookingService {
    private final BookingRepository bookingRepository;
    private final ShowTimeRepository showTimeRepository;
    private final PaymentGateway paymentGateway;
    
    // Constructor with dependency injection
    public BookingServiceImpl(BookingRepository bookingRepository, 
                             ShowTimeRepository showTimeRepository,
                             PaymentGateway paymentGateway) {
        this.bookingRepository = Objects.requireNonNull(bookingRepository);
        this.showTimeRepository = Objects.requireNonNull(showTimeRepository);
        this.paymentGateway = Objects.requireNonNull(paymentGateway);
    }
    
    @Override
    public synchronized ReservationResult reserveSeats(ShowTime showTime, Set<SeatCoordinate> seats, User user) {
        // Check seat availability atomically
        if (!showTime.areAllSeatsAvailable(seats)) {
            return ReservationResult.SEATS_NOT_AVAILABLE;
        }
        
        // Validate show time is in the future
        if (showTime.getStartTime().isBefore(LocalDateTime.now())) {
            return ReservationResult.SHOW_TIME_PASSED;
        }
        
        // Reserve seats atomically
        boolean reserved = showTime.reserveSeats(seats);
        if (!reserved) {
            return ReservationResult.RESERVATION_FAILED;
        }
        
        // Create booking
        Booking booking = new Booking(showTime, seats, user);
        booking.markPaymentPending();
        
        // Save updated entities
        showTimeRepository.save(showTime);
        bookingRepository.save(booking);
        
        return new ReservationResult(ReservationStatus.SUCCESS, booking.getId());
    }
    
    @Override
    public boolean confirmBooking(UUID bookingId, PaymentDetails paymentDetails) {
        // Retrieve booking
        Optional<Booking> optionalBooking = bookingRepository.findById(bookingId);
        if (optionalBooking.isEmpty()) {
            return false;
        }
        
        Booking booking = optionalBooking.get();
        
        // Check if booking is in payment pending state
        if (booking.getStatus() != BookingStatus.PAYMENT_PENDING) {
            return false;
        }
        
        // Process payment
        PaymentResult paymentResult = paymentGateway.processPayment(paymentDetails, calculateTotalPrice(booking));
        if (!paymentResult.isSuccessful()) {
            return false;
        }
        
        // Update booking status
        booking.confirm();
        bookingRepository.save(booking);
        
        // Update seats from reserved to booked
        ShowTime showTime = booking.getShowTime();
        for (SeatCoordinate seat : booking.getSeats()) {
            showTime.bookSeat(seat);
        }
        showTimeRepository.save(showTime);
        
        return true;
    }
    
    @Override
    public boolean cancelBooking(UUID bookingId, User user) {
        // Retrieve booking
        Optional<Booking> optionalBooking = bookingRepository.findById(bookingId);
        if (optionalBooking.isEmpty()) {
            return false;
        }
        
        Booking booking = optionalBooking.get();
        
        // Only the booking owner can cancel
        if (!booking.getUser().equals(user)) {
            throw new UnauthorizedOperationException("Only the booking owner can cancel");
        }
        
        // Check if booking can be cancelled
        if (booking.getStatus() == BookingStatus.COMPLETED || 
            booking.getStatus() == BookingStatus.CANCELLED) {
            return false;
        }
        
        // Update booking status
        booking.cancel();
        bookingRepository.save(booking);
        
        // Release seats
        ShowTime showTime = booking.getShowTime();
        for (SeatCoordinate seat : booking.getSeats()) {
            showTime.releaseSeat(seat);
        }
        showTimeRepository.save(showTime);
        
        return true;
    }
    
    // Helper methods
    private Money calculateTotalPrice(Booking booking) {
        // Implementation of pricing calculation
        // This would use information from both the show time and the seats
        return new Money(BigDecimal.TEN, Currency.getInstance("USD")); // Simplified
    }
}

/**
 * Repository Layer - Type-Safe Data Access
 * Repositories work with domain objects, not DTOs, and maintain type safety.
 */
public interface MovieRepository {
    Optional<Movie> findById(UUID id);
    List<Movie> findAll();
    List<Movie> findByGenre(MovieGenre genre);
    List<Movie> findByCastMember(Person person);
    Movie save(Movie movie);
}

public class InMemoryMovieRepository implements MovieRepository {
    private final Map<UUID, Movie> movies = new ConcurrentHashMap<>();
    
    @Override
    public Optional<Movie> findById(UUID id) {
        return Optional.ofNullable(movies.get(id));
    }
    
    @Override
    public List<Movie> findAll() {
        return new ArrayList<>(movies.values());
    }
    
    @Override
    public List<Movie> findByGenre(MovieGenre genre) {
        return movies.values().stream()
            .filter(movie -> movie.getGenres().contains(genre))
            .collect(Collectors.toList());
    }
    
    @Override
    public List<Movie> findByCastMember(Person person) {
        return movies.values().stream()
            .filter(movie -> movie.hasCastMember(person))
            .collect(Collectors.toList());
    }
    
    @Override
    public Movie save(Movie movie) {
        movies.put(movie.getId(), movie);
        return movie;
    }
}