Parking Lot

public enum VehicleType {
    MOTORCYCLE,
    CAR
}

public enum SpotType {
    MOTORCYCLE,
    COMPACT,
    LARGE;

    public boolean canFit(VehicleType vehicleType) {
        return switch (vehicleType) {
            case MOTORCYCLE -> true;
            case CAR -> this == COMPACT || this == LARGE;
        };
    }

    public int preferenceFor(VehicleType vehicleType) {
        if (!canFit(vehicleType)) return Integer.MAX_VALUE;
        return switch (this) {
            case MOTORCYCLE -> 0;
            case COMPACT -> vehicleType == VehicleType.CAR ? 0 : 1;
            case LARGE -> vehicleType == VehicleType.CAR ? 1 : 2;
        };
    }
}

public enum ParkingStatus {
    PARKED,
    ALREADY_PARKED,
    NO_COMPATIBLE_SPOT
}

public enum ExitStatus {
    RELEASED,
    TICKET_NOT_FOUND
}

import java.util.Locale;
import java.util.Objects;

public record Vehicle(String licensePlate, VehicleType type) {
    public Vehicle {
        if (licensePlate == null || licensePlate.isBlank()) {
            throw new IllegalArgumentException("license plate is required");
        }
        licensePlate = licensePlate.trim().toUpperCase(Locale.ROOT);
        type = Objects.requireNonNull(type, "vehicle type is required");
    }
}

import java.util.Objects;

public record SpotSelection(ParkingFloor floor, ParkingSpot spot) {
    public SpotSelection {
        floor = Objects.requireNonNull(floor);
        spot = Objects.requireNonNull(spot);
    }
}

import java.util.Objects;

public record ParkingTicket(
        String id,
        String licensePlate,
        int floorNumber,
        String spotId) {

    public ParkingTicket {
        if (id == null || id.isBlank()) {
            throw new IllegalArgumentException("ticket id is required");
        }
        if (licensePlate == null || licensePlate.isBlank()) {
            throw new IllegalArgumentException("license plate is required");
        }
        if (floorNumber < 0) {
            throw new IllegalArgumentException("floor number cannot be negative");
        }
        if (spotId == null || spotId.isBlank()) {
            throw new IllegalArgumentException("spot id is required");
        }
    }
}

import java.util.Objects;
import java.util.Optional;

public record ParkingResult(ParkingStatus status, ParkingTicket ticket) {
    public ParkingResult {
        status = Objects.requireNonNull(status);
        if (status == ParkingStatus.PARKED && ticket == null) {
            throw new IllegalArgumentException("PARKED requires a ticket");
        }
        if (status != ParkingStatus.PARKED && ticket != null) {
            throw new IllegalArgumentException("Rejected parking cannot have a ticket");
        }
    }

    public static ParkingResult parked(ParkingTicket ticket) {
        return new ParkingResult(ParkingStatus.PARKED, Objects.requireNonNull(ticket));
    }

    public static ParkingResult rejected(ParkingStatus status) {
        if (status == ParkingStatus.PARKED) {
            throw new IllegalArgumentException("Use parked() for success");
        }
        return new ParkingResult(status, null);
    }

    public Optional<ParkingTicket> optionalTicket() {
        return Optional.ofNullable(ticket);
    }
}

import java.util.Objects;
import java.util.Optional;

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

    public ParkingSpot(String id, SpotType type) {
        if (id == null || id.isBlank()) {
            throw new IllegalArgumentException("spot id is required");
        }
        this.id = id;
        this.type = Objects.requireNonNull(type);
    }

    public boolean canFit(Vehicle vehicle) {
        return vehicle != null && type.canFit(vehicle.type());
    }

    public boolean occupy(Vehicle vehicle) {
        if (occupiedBy != null || !canFit(vehicle)) return false;
        occupiedBy = vehicle;
        return true;
    }

    public boolean release() {
        if (occupiedBy == null) return false;
        occupiedBy = null;
        return true;
    }

    public boolean isAvailable() {
        return occupiedBy == null;
    }

    public String getId() {
        return id;
    }

    public SpotType getType() {
        return type;
    }

    public Optional<Vehicle> getVehicle() {
        return Optional.ofNullable(occupiedBy);
    }
}

import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;

public final class ParkingFloor {
    private final int number;
    private final List<ParkingSpot> spots;

    public ParkingFloor(int number, List<ParkingSpot> spots) {
        if (number < 0) {
            throw new IllegalArgumentException("floor number cannot be negative");
        }
        Objects.requireNonNull(spots);
        if (spots.isEmpty()) {
            throw new IllegalArgumentException("a floor needs at least one spot");
        }

        Set<String> ids = new HashSet<>();
        for (ParkingSpot spot : spots) {
            Objects.requireNonNull(spot);
            if (!ids.add(spot.getId())) {
                throw new IllegalArgumentException("duplicate spot id on floor: " + spot.getId());
            }
        }
        this.number = number;
        this.spots = List.copyOf(spots);
    }

    public Optional<ParkingSpot> findSpot(String spotId) {
        return spots.stream()
                .filter(spot -> spot.getId().equals(spotId))
                .findFirst();
    }

    public int availableSpotCount() {
        return (int) spots.stream().filter(ParkingSpot::isAvailable).count();
    }

    public int getNumber() {
        return number;
    }

    public List<ParkingSpot> getSpots() {
        return spots;
    }
}

import java.util.List;
import java.util.Optional;

public interface SpotAssignmentStrategy {
    Optional<SpotSelection> select(List<ParkingFloor> floors, Vehicle vehicle);
}

import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

public final class NearestAvailableSpotStrategy implements SpotAssignmentStrategy {
    @Override
    public Optional<SpotSelection> select(List<ParkingFloor> floors, Vehicle vehicle) {
        Objects.requireNonNull(floors);
        Objects.requireNonNull(vehicle);

        Comparator<SpotSelection> nearestFirst = Comparator
                .comparingInt((SpotSelection selection) -> selection.floor().getNumber())
                .thenComparingInt(selection ->
                        selection.spot().getType().preferenceFor(vehicle.type()))
                .thenComparing(selection -> selection.spot().getId());

        return floors.stream()
                .flatMap(floor -> floor.getSpots().stream()
                        .filter(ParkingSpot::isAvailable)
                        .filter(spot -> spot.canFit(vehicle))
                        .map(spot -> new SpotSelection(floor, spot)))
                .min(nearestFirst);
    }
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

public final class ParkingLot {
    private final List<ParkingFloor> floors;
    private final SpotAssignmentStrategy strategy;
    private final Map<String, ParkingTicket> activeTicketsById = new LinkedHashMap<>();
    private final Map<String, String> activeTicketIdByPlate = new HashMap<>();
    private int nextTicketNumber = 1;

    public ParkingLot(List<ParkingFloor> floors, SpotAssignmentStrategy strategy) {
        Objects.requireNonNull(floors);
        if (floors.isEmpty()) {
            throw new IllegalArgumentException("parking lot needs at least one floor");
        }
        validateUniqueFloorAndSpotIds(floors);
        this.floors = List.copyOf(floors);
        this.strategy = Objects.requireNonNull(strategy);
    }

    public ParkingResult park(Vehicle vehicle) {
        Objects.requireNonNull(vehicle);
        if (activeTicketIdByPlate.containsKey(vehicle.licensePlate())) {
            return ParkingResult.rejected(ParkingStatus.ALREADY_PARKED);
        }

        SpotSelection selection = strategy.select(floors, vehicle).orElse(null);
        if (selection == null) {
            return ParkingResult.rejected(ParkingStatus.NO_COMPATIBLE_SPOT);
        }
        if (!selection.spot().occupy(vehicle)) {
            throw new IllegalStateException("strategy returned an unusable spot");
        }

        String ticketId = String.format("T%03d", nextTicketNumber++);
        ParkingTicket ticket = new ParkingTicket(
                ticketId,
                vehicle.licensePlate(),
                selection.floor().getNumber(),
                selection.spot().getId());
        activeTicketsById.put(ticketId, ticket);
        activeTicketIdByPlate.put(vehicle.licensePlate(), ticketId);
        return ParkingResult.parked(ticket);
    }

    public ExitStatus leave(String ticketId) {
        if (ticketId == null || ticketId.isBlank()) {
            return ExitStatus.TICKET_NOT_FOUND;
        }
        ParkingTicket ticket = activeTicketsById.get(ticketId);
        if (ticket == null) return ExitStatus.TICKET_NOT_FOUND;

        ParkingSpot spot = floors.stream()
                .filter(floor -> floor.getNumber() == ticket.floorNumber())
                .findFirst()
                .flatMap(floor -> floor.findSpot(ticket.spotId()))
                .orElseThrow(() -> new IllegalStateException("ticket points to a missing spot"));
        if (!spot.release()) {
            throw new IllegalStateException("ticket points to an empty spot");
        }

        activeTicketsById.remove(ticketId);
        activeTicketIdByPlate.remove(ticket.licensePlate());
        return ExitStatus.RELEASED;
    }

    public List<ParkingTicket> getActiveTickets() {
        return List.copyOf(activeTicketsById.values());
    }

    public List<ParkingFloor> getFloors() {
        return floors;
    }

    private static void validateUniqueFloorAndSpotIds(List<ParkingFloor> floors) {
        Set<Integer> floorNumbers = new HashSet<>();
        Set<String> spotIds = new HashSet<>();
        for (ParkingFloor floor : floors) {
            Objects.requireNonNull(floor);
            if (!floorNumbers.add(floor.getNumber())) {
                throw new IllegalArgumentException("duplicate floor: " + floor.getNumber());
            }
            for (ParkingSpot spot : floor.getSpots()) {
                if (!spotIds.add(spot.getId())) {
                    throw new IllegalArgumentException("duplicate spot id: " + spot.getId());
                }
            }
        }
    }
}

import java.util.List;

public final class ParkingLotDemo {
    public static void main(String[] args) {
        ParkingFloor ground = new ParkingFloor(0, List.of(
                new ParkingSpot("M-01", SpotType.MOTORCYCLE),
                new ParkingSpot("C-01", SpotType.COMPACT),
                new ParkingSpot("L-01", SpotType.LARGE)));
        ParkingFloor first = new ParkingFloor(1, List.of(
                new ParkingSpot("C-11", SpotType.COMPACT),
                new ParkingSpot("L-11", SpotType.LARGE)));

        ParkingLot lot = new ParkingLot(
                List.of(ground, first),
                new NearestAvailableSpotStrategy());

        Vehicle carOne = new Vehicle("ka-01-ab-1001", VehicleType.CAR);
        ParkingResult firstEntry = lot.park(carOne);
        print(firstEntry);

        ParkingResult duplicate = lot.park(carOne);
        System.out.println("Duplicate: " + duplicate.status()
                + ", active tickets: " + lot.getActiveTickets().size());

        print(lot.park(new Vehicle("KA-01-AB-1002", VehicleType.CAR)));
        print(lot.park(new Vehicle("KA-01-AB-1003", VehicleType.CAR)));
        print(lot.park(new Vehicle("KA-01-AB-1004", VehicleType.CAR)));
        print(lot.park(new Vehicle("KA-01-AB-1005", VehicleType.CAR)));

        String firstTicketId = firstEntry.ticket().id();
        System.out.println("Exit " + firstTicketId + ": " + lot.leave(firstTicketId));
        print(lot.park(new Vehicle("KA-01-AB-1005", VehicleType.CAR)));
        System.out.println("Unknown exit: " + lot.leave("T999"));
    }

    private static void print(ParkingResult result) {
        if (result.status() != ParkingStatus.PARKED) {
            System.out.println("Entry: " + result.status());
            return;
        }
        ParkingTicket ticket = result.ticket();
        System.out.printf("%s -> %s on floor %d, spot %s%n",
                result.status(), ticket.id(), ticket.floorNumber(), ticket.spotId());
    }
}