Design Parking Lot

public enum VehicleType { BIKE, CAR, TRUCK }

public enum SpotSize { SMALL, MEDIUM, LARGE }

public enum SpotStatus { FREE, OCCUPIED }

public final class VehicleSizeMapper {
    // Private ctor — utility class, no instances
    private VehicleSizeMapper() {}

    // Returns smallest spot size that can fit this vehicle type
    public static SpotSize requiredSpot(VehicleType type) {
        return switch (type) {
            case BIKE -> SpotSize.SMALL;
            case CAR  -> SpotSize.MEDIUM;
            case TRUCK -> SpotSize.LARGE;
        };
    }
}

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

    // Creates an immutable vehicle with plate and type
    public Vehicle(String licensePlate, VehicleType type) {
        this.licensePlate = Objects.requireNonNull(licensePlate);
        this.type = Objects.requireNonNull(type);
    }

    // Returns license plate for ticket / duplicate-entry checks
    public String getLicensePlate() { return licensePlate; }

    // Returns vehicle type for spot-size and pricing lookups
    public VehicleType getType() { return type; }
}

public class ParkingSpot {
    private final String id;
    private final SpotSize size;
    private SpotStatus status = SpotStatus.FREE;
    private Vehicle parkedVehicle;

    // Creates a spot with fixed id and size tier
    public ParkingSpot(String id, SpotSize size) {
        this.id = id;
        this.size = size;
    }

    // True if this spot is large enough for the vehicle type
    public boolean canFit(Vehicle vehicle) {
        SpotSize need = VehicleSizeMapper.requiredSpot(vehicle.getType());
        return size.ordinal() >= need.ordinal();
    }

    // Atomically parks vehicle; false if occupied or size mismatch
    public synchronized boolean park(Vehicle vehicle) {
        if (status == SpotStatus.OCCUPIED || !canFit(vehicle)) return false;
        this.parkedVehicle = vehicle;
        this.status = SpotStatus.OCCUPIED;
        return true;
    }

    // Frees spot and returns parked vehicle; empty if already free
    public synchronized Optional<Vehicle> unpark() {
        if (status == SpotStatus.FREE) return Optional.empty();
        Vehicle v = parkedVehicle;
        parkedVehicle = null;
        status = SpotStatus.FREE;
        return Optional.of(v);
    }

    // True when spot can accept a new park request
    public boolean isFree() { return status == SpotStatus.FREE; }

    // Returns spot id for tickets and display boards
    public String getId() { return id; }
}

public class Floor {
    private final int level;
    private final List<ParkingSpot> spots = new ArrayList<>();

    // Creates a floor at the given level number
    public Floor(int level) { this.level = level; }

    // Registers a spot on this floor
    public void addSpot(ParkingSpot spot) { spots.add(spot); }

    // Returns first free spot on this floor that fits the vehicle
    public Optional<ParkingSpot> findAvailableSpot(Vehicle vehicle) {
        return spots.stream()
            .filter(ParkingSpot::isFree)
            .filter(s -> s.canFit(vehicle))
            .findFirst();
    }

    // Counts free spots on this floor (for availability board)
    public long freeCount() {
        return spots.stream().filter(ParkingSpot::isFree).count();
    }

    // Read-only view of all spots on the floor
    public List<ParkingSpot> getSpots() { return Collections.unmodifiableList(spots); }
}

public class Ticket {
    private final String ticketId;
    private final Vehicle vehicle;
    private final ParkingSpot spot;
    private final Instant entryTime;

    // Issued on park: binds vehicle, spot, and entry time for fee on exit
    public Ticket(Vehicle vehicle, ParkingSpot spot) {
        this.ticketId = UUID.randomUUID().toString();
        this.vehicle = vehicle;
        this.spot = spot;
        this.entryTime = Instant.now();
    }

    // Id shown to user at gate for unpark
    public String getTicketId() { return ticketId; }

    // Used by pricing strategy to compute duration
    public Instant getEntryTime() { return entryTime; }

    // Spot to free when vehicle leaves
    public ParkingSpot getSpot() { return spot; }

    // Vehicle type drives hourly rate lookup
    public Vehicle getVehicle() { return vehicle; }
}

public interface PricingStrategy {
    // Computes exit fee from ticket and exit timestamp
    BigDecimal calculateFee(Ticket ticket, Instant exitTime);
}

public class HourlyPricingStrategy implements PricingStrategy {
    private final Map<VehicleType, BigDecimal> hourlyRate;

    // Loads per-vehicle-type hourly rates
    public HourlyPricingStrategy(Map<VehicleType, BigDecimal> hourlyRate) {
        this.hourlyRate = hourlyRate;
    }

    // Bills at least one hour; rate chosen by vehicle type on ticket
    @Override
    public BigDecimal calculateFee(Ticket ticket, Instant exitTime) {
        long minutes = Duration.between(ticket.getEntryTime(), exitTime).toMinutes();
        long hours = Math.max(1, (minutes + 59) / 60);
        BigDecimal rate = hourlyRate.get(ticket.getVehicle().getType());
        return rate.multiply(BigDecimal.valueOf(hours));
    }
}

public class ParkingLot {
    private final String name;
    private final List<Floor> floors = new ArrayList<>();
    private final PricingStrategy pricingStrategy;
    private final Map<String, Ticket> activeTickets = new ConcurrentHashMap<>();

    // Builds lot with name and injectable pricing strategy
    public ParkingLot(String name, PricingStrategy pricingStrategy) {
        this.name = name;
        this.pricingStrategy = pricingStrategy;
    }

    // Adds a floor to the lot structure
    public void addFloor(Floor floor) { floors.add(floor); }

    // Finds compatible spot, parks vehicle, returns ticket; empty if full
    public synchronized Optional<Ticket> parkVehicle(Vehicle vehicle) {
        for (Floor floor : floors) {
            Optional<ParkingSpot> spot = floor.findAvailableSpot(vehicle);
            if (spot.isPresent() && spot.get().park(vehicle)) {
                Ticket ticket = new Ticket(vehicle, spot.get());
                activeTickets.put(ticket.getTicketId(), ticket);
                return Optional.of(ticket);
            }
        }
        return Optional.empty();
    }

    // Frees spot, removes ticket, returns fee; empty if invalid ticket id
    public synchronized Optional<BigDecimal> unparkVehicle(String ticketId) {
        Ticket ticket = activeTickets.remove(ticketId);
        if (ticket == null) return Optional.empty();

        ticket.getSpot().unpark();
        Instant exit = Instant.now();
        return Optional.of(pricingStrategy.calculateFee(ticket, exit));
    }

    // Counts free spots that can fit the given vehicle type (display board)
    public int availableSpots(VehicleType type) {
        Vehicle probe = new Vehicle("PROBE", type);
        return (int) floors.stream()
            .flatMap(f -> f.getSpots().stream())
            .filter(ParkingSpot::isFree)
            .filter(s -> s.canFit(probe))
            .count();
    }
}

public class VehicleFactory {
    // Central place to construct vehicles (extend for new types later)
    public static Vehicle create(VehicleType type, String plate) {
        return new Vehicle(plate, type);
    }
}

public class ParkingLotDemo {
    // Wires floors, spots, park, and unpark with fee printout
    public static void main(String[] args) {
        Map<VehicleType, BigDecimal> rates = Map.of(
            VehicleType.BIKE, new BigDecimal("20"),
            VehicleType.CAR,  new BigDecimal("40"),
            VehicleType.TRUCK, new BigDecimal("80")
        );
        ParkingLot lot = new ParkingLot("City Mall", new HourlyPricingStrategy(rates));

        Floor f1 = new Floor(1);
        f1.addSpot(new ParkingSpot("F1-S1", SpotSize.SMALL));
        f1.addSpot(new ParkingSpot("F1-M1", SpotSize.MEDIUM));
        f1.addSpot(new ParkingSpot("F1-L1", SpotSize.LARGE));
        lot.addFloor(f1);

        Vehicle car = VehicleFactory.create(VehicleType.CAR, "KA-01-AB-1234");
        Optional<Ticket> ticket = lot.parkVehicle(car);
        ticket.ifPresent(t -> {
            System.out.println("Parked. Ticket: " + t.getTicketId());
            lot.unparkVehicle(t.getTicketId())
               .ifPresent(fee -> System.out.println("Fee: ₹" + fee));
        });
    }
}