Design a Parking Lot System

public enum SpotSize { COMPACT, REGULAR, LARGE }
public enum VehicleType { MOTORCYCLE, CAR, TRUCK }

public class Vehicle {
    private final String licensePlate;
    private final VehicleType type;

    public SpotSize getRequiredSize() {
        return switch (type) {
            case MOTORCYCLE -> SpotSize.COMPACT;
            case CAR -> SpotSize.REGULAR;
            case TRUCK -> SpotSize.LARGE;
        };
    }
}

public class ParkingSpot {
    private final String spotId;
    private final int floor;
    private final SpotSize size;
    private volatile boolean occupied;
    private Vehicle currentVehicle;
    private int version; // for optimistic locking

    public synchronized boolean assign(Vehicle vehicle) {
        if (occupied || !canFit(vehicle)) return false;
        this.occupied = true;
        this.currentVehicle = vehicle;
        this.version++;
        return true;
    }

    public synchronized void release() {
        this.occupied = false;
        this.currentVehicle = null;
        this.version++;
    }

    public boolean canFit(Vehicle vehicle) {
        return vehicle.getRequiredSize().ordinal() <= this.size.ordinal();
    }
}

public class ParkingLotService {
    private final List<Floor> floors;
    private final PricingStrategy pricingStrategy;
    private final Map<String, ParkingTicket> activeTickets = new ConcurrentHashMap<>();

    public ParkingTicket entry(Vehicle vehicle) {
        ParkingSpot spot = findAndAssignSpot(vehicle);
        if (spot == null) throw new ParkingFullException("No spots available");

        ParkingTicket ticket = new ParkingTicket(
            UUID.randomUUID().toString(), vehicle, spot, LocalDateTime.now()
        );
        activeTickets.put(ticket.getTicketId(), ticket);
        notifyDisplays(); // Observer pattern
        return ticket;
    }

    public Payment exit(String ticketId) {
        ParkingTicket ticket = activeTickets.remove(ticketId);
        if (ticket == null) throw new InvalidTicketException(ticketId);

        ticket.setExitTime(LocalDateTime.now());
        Duration parked = Duration.between(ticket.getEntryTime(), ticket.getExitTime());
        double fee = pricingStrategy.calculateFee(parked, ticket.getVehicle().getType());

        ticket.getSpot().release();
        notifyDisplays();
        return new Payment(ticket, fee);
    }

    private ParkingSpot findAndAssignSpot(Vehicle vehicle) {
        // Nearest spot: iterate floors bottom-up, spots left-to-right
        for (Floor floor : floors) {
            ParkingSpot spot = floor.getAvailableSpot(vehicle.getType());
            if (spot != null && spot.assign(vehicle)) {
                return spot;
            }
        }
        return null;
    }
}

public interface PricingStrategy {
    double calculateFee(Duration duration, VehicleType type);
}

public class HourlyPricingStrategy implements PricingStrategy {
    private static final Map<VehicleType, Double> HOURLY_RATES = Map.of(
        VehicleType.MOTORCYCLE, 1.0,
        VehicleType.CAR, 2.0,
        VehicleType.TRUCK, 4.0
    );

    @Override
    public double calculateFee(Duration duration, VehicleType type) {
        long hours = Math.max(1, (long) Math.ceil(duration.toMinutes() / 60.0));
        return hours * HOURLY_RATES.get(type);
    }
}

// Easy to swap: FlatRatePricing, DynamicSurgePricing, WeekendPricing
public class DynamicPricingStrategy implements PricingStrategy {
    @Override
    public double calculateFee(Duration duration, VehicleType type) {
        double baseRate = HourlyPricingStrategy.HOURLY_RATES.get(type);
        double occupancy = getCurrentOccupancyRatio();
        double multiplier = occupancy > 0.8 ? 1.5 : 1.0; // surge pricing
        long hours = Math.max(1, (long) Math.ceil(duration.toMinutes() / 60.0));
        return hours * baseRate * multiplier;
    }
}

// Problem: Two gates try to assign the same spot simultaneously
// Solution: Optimistic locking with retry

public class Floor {
    private final List<ParkingSpot> spots;
    private final ReentrantLock assignLock = new ReentrantLock();

    public ParkingSpot getAvailableSpot(VehicleType vehicleType) {
        // Lock-free read: find candidates
        List<ParkingSpot> candidates = spots.stream()
            .filter(s -> !s.isOccupied() && s.canFit(vehicleType))
            .sorted(Comparator.comparing(ParkingSpot::getSpotId))
            .toList();

        // Try to assign with optimistic lock
        for (ParkingSpot spot : candidates) {
            if (spot.assign(vehicleType)) { // synchronized internally
                return spot;
            }
            // If assign fails, another gate took it — try next candidate
        }
        return null; // Floor full for this vehicle type
    }
}