Design a Parking Lot

public enum VehicleType {
    CAR, BIKE, TRUCK
}

public enum SpotType {
    CAR(VehicleType.CAR),
    BIKE(VehicleType.BIKE),
    TRUCK(VehicleType.TRUCK);

    private final VehicleType compatibleVehicleType;

    SpotType(VehicleType compatibleVehicleType) {
        this.compatibleVehicleType = compatibleVehicleType;
    }

    public boolean canFitVehicle(VehicleType vehicleType) {
        return this.compatibleVehicleType == vehicleType;
    }
}

public abstract class Vehicle {
    protected String licensePlate;
    protected VehicleType vehicleType;

    public Vehicle(String licensePlate, VehicleType type) {
        this.licensePlate = licensePlate;
        this.vehicleType  = type;
    }

    public VehicleType getVehicleType() { return vehicleType; }
    public String getLicenseNumber()    { return licensePlate; }
}

public class Car extends Vehicle {
    public Car(String plate) { super(plate, VehicleType.CAR); }
}

public class Bike extends Vehicle {
    public Bike(String plate) { super(plate, VehicleType.BIKE); }
}

public class Truck extends Vehicle {
    public Truck(String plate) { super(plate, VehicleType.TRUCK); }
}

public class ParkingSpot {
    private int spotId;
    private SpotType spotType;
    private boolean isOccupied;
    private Vehicle parkedVehicle;

    public ParkingSpot(SpotType spotType, int spotId) {
        this.isOccupied = false;
        this.spotId     = spotId;
        this.spotType   = spotType;
    }

    public void occupySpot(Vehicle vehicle) {
        this.parkedVehicle = vehicle;
        this.isOccupied    = true;
    }

    public void vacateSpot() {
        this.parkedVehicle = null;
        this.isOccupied    = false;
    }

    public boolean isOccupied()   { return isOccupied; }
    public SpotType getSpotType() { return spotType; }
    public int getSpotId()        { return spotId; }
}

import java.util.List;

public class ParkingLevel {
    private int levelId;
    private List<ParkingSpot> parkingSpots;

    public ParkingLevel(int levelId, List<ParkingSpot> spots) {
        this.levelId      = levelId;
        this.parkingSpots = spots;
    }

    public ParkingSpot findParkingSpot(VehicleType type) {
        for (ParkingSpot spot : parkingSpots) {
            if (!spot.isOccupied() && spot.getSpotType().canFitVehicle(type)) {
                return spot;
            }
        }
        return null;
    }

    public boolean isFull() {
        for (ParkingSpot spot : parkingSpots) {
            if (!spot.isOccupied()) return false;
        }
        return true;
    }
}

public enum TicketStatus {
    ACTIVE, COMPLETED
}

import java.time.LocalTime;
import java.util.UUID;

public class ParkingLotTicket {
    private final UUID ticketId;
    private final Vehicle vehicle;
    private final ParkingSpot parkingSpot;
    private final LocalTime entryTime;
    private TicketStatus status;

    private ParkingLotTicket(Builder builder) {
        this.ticketId    = builder.ticketId;
        this.vehicle     = builder.vehicle;
        this.parkingSpot = builder.parkingSpot;
        this.entryTime   = builder.entryTime;
        this.status      = TicketStatus.ACTIVE;
    }

    public UUID getTicketId()          { return ticketId; }
    public Vehicle getVehicle()        { return vehicle; }
    public ParkingSpot getParkingSpot(){ return parkingSpot; }
    public LocalTime getEntryTime()    { return entryTime; }
    public TicketStatus getStatus()    { return status; }

    public void markCompleted() { this.status = TicketStatus.COMPLETED; }

    public static class Builder {
        private UUID ticketId;
        private Vehicle vehicle;
        private ParkingSpot parkingSpot;
        private LocalTime entryTime;

        public Builder vehicle(Vehicle v)         { this.vehicle = v;      return this; }
        public Builder parkingSpot(ParkingSpot s) { this.parkingSpot = s;  return this; }
        public Builder entryTime(LocalTime t)     { this.entryTime = t;    return this; }

        public ParkingLotTicket build() {
            if (vehicle == null || parkingSpot == null || entryTime == null)
                throw new IllegalStateException("vehicle, parkingSpot, and entryTime are required");
            this.ticketId = UUID.randomUUID();
            return new ParkingLotTicket(this);
        }
    }
}

import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

public class TicketInventory {
    private final Map<UUID, ParkingLotTicket> tickets = new ConcurrentHashMap<>();

    public synchronized void addTicket(ParkingLotTicket ticket) {
        tickets.put(ticket.getTicketId(), ticket);
    }

    public synchronized ParkingLotTicket getTicketById(UUID ticketId) {
        return tickets.get(ticketId);
    }
}

public interface PaymentStrategy {
    double calculate(long durationInMinutes);
}

// $2.00 / hour, rounds up partial hours
public class HourlyPaymentStrategy implements PaymentStrategy {
    private static final double HOURLY_RATE = 2.0;

    @Override
    public double calculate(long duration) {
        long hours = duration / 60;
        if (duration % 60 != 0) hours++;
        return HOURLY_RATE * hours;
    }
}

// $0.05 / minute
public class MinutePaymentStrategy implements PaymentStrategy {
    private static final double MINUTE_RATE = 0.05;

    @Override
    public double calculate(long duration) {
        return MINUTE_RATE * duration;
    }
}

import java.time.LocalTime;
import java.time.temporal.ChronoUnit;

public class PaymentService {
    public double calculatePaymentAmount(
            ParkingLotTicket ticket,
            PaymentStrategy strategy,
            LocalTime exitTime) {
        long minutes = ticket.getEntryTime().until(exitTime, ChronoUnit.MINUTES);
        return strategy.calculate(minutes);
    }

    public boolean processPayment(double amount, ParkingLotTicket ticket) {
        System.out.printf("Payment of $%.2f processed for ticket %s%n",
                amount, ticket.getTicketId());
        return true;
    }
}