Parking Lot System

classDiagram
  class ParkingLot {
    -List~Spot~ spots
    +park(Vehicle) Ticket
    +unpark(Ticket) void
  }
  class Vehicle
  class ParkingSpot
  class Ticket
  ParkingLot --> ParkingSpot
  ParkingLot --> Ticket
  Vehicle --> ParkingSpot

public enum SpotType { COMPACT, LARGE, BIKE }

public sealed interface Vehicle permits CarVehicle, TruckVehicle, BikeVehicle {
    String plate();
    SpotType requiredSpot();
}

public record CarVehicle(String plate) implements Vehicle {
    public SpotType requiredSpot() { return SpotType.COMPACT; }
}

public record TruckVehicle(String plate) implements Vehicle {
    public SpotType requiredSpot() { return SpotType.LARGE; }
}

public record BikeVehicle(String plate) implements Vehicle {
    public SpotType requiredSpot() { return SpotType.BIKE; }
}

public final class ParkingSpot {
    private final int id;
    private final SpotType type;
    private Vehicle occupiedBy;

    public ParkingSpot(int id, SpotType type) {
        this.id = id;
        this.type = type;
    }

    public boolean isFree() { return occupiedBy == null; }
    public boolean supports(SpotType t) { return type == t; }

    public synchronized void park(Vehicle v) {
        if (!isFree()) throw new IllegalStateException("occupied");
        occupiedBy = v;
    }

    public synchronized void release() { occupiedBy = null; }
}

public final class Ticket {
    private final String id;
    private final ParkingSpot spot;
    private final Vehicle vehicle;
    private final Instant entry;

    private Ticket(ParkingSpot spot, Vehicle vehicle) {
        this.id = UUID.randomUUID().toString();
        this.spot = spot;
        this.vehicle = vehicle;
        this.entry = Instant.now();
    }

    public static Ticket issue(ParkingSpot spot, Vehicle vehicle) {
        return new Ticket(spot, vehicle);
    }

    public String id() { return id; }
    public ParkingSpot spot() { return spot; }
    public Instant entry() { return entry; }

    public Money calculateFee(Money hourlyRate) {
        long hours = (long) Math.ceil(Duration.between(entry, Instant.now()).toMinutes() / 60.0);
        return hourlyRate.multiply(Math.max(1, hours));
    }
}

public final class ParkingLot {
    private final List<ParkingSpot> spots = new ArrayList<>();
    private final Map<String, Ticket> active = new ConcurrentHashMap<>();

    public void addSpot(ParkingSpot spot) { spots.add(spot); }

    public synchronized Ticket park(Vehicle vehicle) {
        ParkingSpot spot = spots.stream()
            .filter(s -> s.isFree() && s.supports(vehicle.requiredSpot()))
            .findFirst()
            .orElseThrow(() -> new IllegalStateException("full"));
        spot.park(vehicle);
        Ticket ticket = Ticket.issue(spot, vehicle);
        active.put(ticket.id(), ticket);
        return ticket;
    }

    public synchronized Money unpark(String ticketId) {
        Ticket ticket = active.remove(ticketId);
        if (ticket == null) throw new IllegalArgumentException("invalid ticket");
        Money fee = ticket.calculateFee(Money.of(5));
        ticket.spot().release();
        return fee;
    }
}