Design a Parking Lot System

public enum VehicleType {
    MOTORCYCLE, CAR, BUS, TRUCK
}

public enum SpotType {
    MOTORCYCLE, COMPACT, LARGE, HANDICAPPED, ELECTRIC
}

public enum TicketStatus {
    ACTIVE, PAID, EXITED, LOST
}

public abstract class Vehicle {
    private String licensePlate;
    private VehicleType type;
    private String color;
    
    public Vehicle(String licensePlate, VehicleType type, String color) {
        this.licensePlate = licensePlate;
        this.type = type;
        this.color = color;
    }
    
    public VehicleType getType() { return type; }
    public String getLicensePlate() { return licensePlate; }
}

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

public class Motorcycle extends Vehicle {
    public Motorcycle(String licensePlate, String color) {
        super(licensePlate, VehicleType.MOTORCYCLE, color);
    }
}

public class Bus extends Vehicle {
    public Bus(String licensePlate, String color) {
        super(licensePlate, VehicleType.BUS, color);
    }
}

public abstract class ParkingSpot {
    private String spotNumber;
    private SpotType spotType;
    private Vehicle vehicle;
    
    public ParkingSpot(String spotNumber, SpotType spotType) {
        this.spotNumber = spotNumber;
        this.spotType = spotType;
    }
    
    public boolean isAvailable() {
        return vehicle == null;
    }
    
    public boolean assignVehicle(Vehicle vehicle) {
        if (!isAvailable() || !canFitVehicle(vehicle)) {
            return false;
        }
        this.vehicle = vehicle;
        return true;
    }
    
    public Vehicle removeVehicle() {
        Vehicle v = this.vehicle;
        this.vehicle = null;
        return v;
    }
    
    public abstract boolean canFitVehicle(Vehicle vehicle);
    
    // Getters
    public String getSpotNumber() { return spotNumber; }
    public SpotType getSpotType() { return spotType; }
    public Vehicle getVehicle() { return vehicle; }
}

public class CompactSpot extends ParkingSpot {
    public CompactSpot(String spotNumber) {
        super(spotNumber, SpotType.COMPACT);
    }
    
    @Override
    public boolean canFitVehicle(Vehicle vehicle) {
        return vehicle.getType() == VehicleType.CAR || 
               vehicle.getType() == VehicleType.MOTORCYCLE;
    }
}

public class LargeSpot extends ParkingSpot {
    public LargeSpot(String spotNumber) {
        super(spotNumber, SpotType.LARGE);
    }
    
    @Override
    public boolean canFitVehicle(Vehicle vehicle) {
        return true; // Large spots can fit all vehicle types
    }
}

public class MotorcycleSpot extends ParkingSpot {
    public MotorcycleSpot(String spotNumber) {
        super(spotNumber, SpotType.MOTORCYCLE);
    }
    
    @Override
    public boolean canFitVehicle(Vehicle vehicle) {
        return vehicle.getType() == VehicleType.MOTORCYCLE;
    }
}

public class ParkingTicket {
    private String ticketNumber;
    private LocalDateTime entryTime;
    private LocalDateTime exitTime;
    private Vehicle vehicle;
    private ParkingSpot spot;
    private TicketStatus status;
    
    public ParkingTicket(String ticketNumber, Vehicle vehicle, ParkingSpot spot) {
        this.ticketNumber = ticketNumber;
        this.vehicle = vehicle;
        this.spot = spot;
        this.entryTime = LocalDateTime.now();
        this.status = TicketStatus.ACTIVE;
    }
    
    public void markExited() {
        this.exitTime = LocalDateTime.now();
        this.status = TicketStatus.EXITED;
    }
    
    public long getDurationInHours() {
        LocalDateTime end = exitTime != null ? exitTime : LocalDateTime.now();
        long minutes = ChronoUnit.MINUTES.between(entryTime, end);
        return (long) Math.ceil(minutes / 60.0); // Round up
    }
    
    // Getters
    public String getTicketNumber() { return ticketNumber; }
    public Vehicle getVehicle() { return vehicle; }
    public ParkingSpot getSpot() { return spot; }
    public TicketStatus getStatus() { return status; }
    public LocalDateTime getEntryTime() { return entryTime; }
}

public class ParkingFloor {
    private int floorNumber;
    private Map<SpotType, List<ParkingSpot>> spots;
    
    public ParkingFloor(int floorNumber) {
        this.floorNumber = floorNumber;
        this.spots = new EnumMap<>(SpotType.class);
        for (SpotType type : SpotType.values()) {
            spots.put(type, new ArrayList<>());
        }
    }
    
    public void addSpot(ParkingSpot spot) {
        spots.get(spot.getSpotType()).add(spot);
    }
    
    public ParkingSpot findAvailableSpot(VehicleType vehicleType) {
        List<SpotType> priority = getSpotPriority(vehicleType);
        
        for (SpotType spotType : priority) {
            List<ParkingSpot> spotList = spots.get(spotType);
            for (ParkingSpot spot : spotList) {
                if (spot.isAvailable()) {
                    return spot;
                }
            }
        }
        return null;
    }
    
    private List<SpotType> getSpotPriority(VehicleType vehicleType) {
        switch (vehicleType) {
            case MOTORCYCLE:
                return Arrays.asList(SpotType.MOTORCYCLE, SpotType.COMPACT, SpotType.LARGE);
            case CAR:
                return Arrays.asList(SpotType.COMPACT, SpotType.LARGE);
            case BUS:
            case TRUCK:
                return Arrays.asList(SpotType.LARGE);
            default:
                return Arrays.asList(SpotType.LARGE);
        }
    }
    
    public int getAvailableCount(SpotType spotType) {
        return (int) spots.get(spotType).stream()
            .filter(ParkingSpot::isAvailable)
            .count();
    }
    
    public int getFloorNumber() { return floorNumber; }
}

public interface PricingStrategy {
    double calculateFee(ParkingTicket ticket);
}

public class HourlyPricingStrategy implements PricingStrategy {
    private Map<VehicleType, Double> hourlyRates;
    
    public HourlyPricingStrategy() {
        hourlyRates = new EnumMap<>(VehicleType.class);
        hourlyRates.put(VehicleType.MOTORCYCLE, 10.0);
        hourlyRates.put(VehicleType.CAR, 20.0);
        hourlyRates.put(VehicleType.BUS, 50.0);
        hourlyRates.put(VehicleType.TRUCK, 50.0);
    }
    
    @Override
    public double calculateFee(ParkingTicket ticket) {
        long hours = ticket.getDurationInHours();
        VehicleType type = ticket.getVehicle().getType();
        double rate = hourlyRates.getOrDefault(type, 20.0);
        return hours * rate;
    }
}

public class FlatRatePricingStrategy implements PricingStrategy {
    private double flatRate;
    
    public FlatRatePricingStrategy(double flatRate) {
        this.flatRate = flatRate;
    }
    
    @Override
    public double calculateFee(ParkingTicket ticket) {
        return flatRate;
    }
}

public class ParkingLot {
    private static ParkingLot instance;
    
    private String name;
    private List<ParkingFloor> floors;
    private Map<String, ParkingTicket> tickets;
    private AtomicInteger ticketCounter;
    private PricingStrategy pricingStrategy;
    
    private ParkingLot(String name) {
        this.name = name;
        this.floors = new ArrayList<>();
        this.tickets = new ConcurrentHashMap<>();
        this.ticketCounter = new AtomicInteger(0);
        this.pricingStrategy = new HourlyPricingStrategy();
    }
    
    public static synchronized ParkingLot getInstance(String name) {
        if (instance == null) {
            instance = new ParkingLot(name);
        }
        return instance;
    }
    
    public static ParkingLot getInstance() {
        return getInstance("Default Parking Lot");
    }
    
    public void addFloor(ParkingFloor floor) {
        floors.add(floor);
    }
    
    public void setPricingStrategy(PricingStrategy strategy) {
        this.pricingStrategy = strategy;
    }
    
    public ParkingTicket parkVehicle(Vehicle vehicle) {
        // Find available spot
        for (ParkingFloor floor : floors) {
            ParkingSpot spot = floor.findAvailableSpot(vehicle.getType());
            if (spot != null && spot.assignVehicle(vehicle)) {
                // Create ticket
                String ticketNumber = "T-" + ticketCounter.incrementAndGet();
                ParkingTicket ticket = new ParkingTicket(ticketNumber, vehicle, spot);
                tickets.put(ticketNumber, ticket);
                return ticket;
            }
        }
        return null; // Parking lot is full
    }
    
    public double unparkVehicle(String ticketNumber) {
        ParkingTicket ticket = tickets.get(ticketNumber);
        if (ticket == null) {
            throw new IllegalArgumentException("Invalid ticket");
        }
        
        if (ticket.getStatus() == TicketStatus.EXITED) {
            throw new IllegalStateException("Ticket already used");
        }
        
        // Mark ticket as exited
        ticket.markExited();
        
        // Free the spot
        ticket.getSpot().removeVehicle();
        
        // Calculate and return fee
        return pricingStrategy.calculateFee(ticket);
    }
    
    public Map<SpotType, Integer> getAvailableSpots() {
        Map<SpotType, Integer> counts = new EnumMap<>(SpotType.class);
        for (SpotType type : SpotType.values()) {
            counts.put(type, 0);
        }
        
        for (ParkingFloor floor : floors) {
            for (SpotType type : SpotType.values()) {
                int current = counts.get(type);
                counts.put(type, current + floor.getAvailableCount(type));
            }
        }
        return counts;
    }
    
    public boolean isFull() {
        return getAvailableSpots().values().stream()
            .allMatch(count -> count == 0);
    }
}

public class ParkingLotDemo {
    public static void main(String[] args) {
        // Get singleton instance
        ParkingLot lot = ParkingLot.getInstance("Downtown Parking");
        
        // Create floor with spots
        ParkingFloor floor1 = new ParkingFloor(1);
        for (int i = 1; i <= 5; i++) {
            floor1.addSpot(new MotorcycleSpot("1-M" + i));
        }
        for (int i = 1; i <= 20; i++) {
            floor1.addSpot(new CompactSpot("1-C" + i));
        }
        for (int i = 1; i <= 10; i++) {
            floor1.addSpot(new LargeSpot("1-L" + i));
        }
        lot.addFloor(floor1);
        
        // Display available spots
        System.out.println("Available spots: " + lot.getAvailableSpots());
        // Output: {MOTORCYCLE=5, COMPACT=20, LARGE=10, ...}
        
        // Park a car
        Vehicle car = new Car("ABC-123", "Red");
        ParkingTicket ticket = lot.parkVehicle(car);
        
        if (ticket != null) {
            System.out.println("Car parked at spot: " + ticket.getSpot().getSpotNumber());
            System.out.println("Ticket: " + ticket.getTicketNumber());
        }
        
        // Simulate some time passing...
        // Thread.sleep(3600000); // 1 hour
        
        // Unpark and pay
        double fee = lot.unparkVehicle(ticket.getTicketNumber());
        System.out.println("Parking fee: $" + fee);
        
        // Check spots again
        System.out.println("Available spots after exit: " + lot.getAvailableSpots());
    }
}