Design a Parking Lot

// Enums for Spot and Vehicle Types
public enum VehicleType {
    CAR, TRUCK, ELECTRIC, VAN, MOTORCYCLE
}

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

// Vehicle base class and its derived classes
public abstract class Vehicle {
    private String licenseNumber;
    private final VehicleType type;

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

    public VehicleType getType() {
        return type;
    }

    public String getLicenseNumber() {
        return licenseNumber;
    }
}

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

public class ElectricCar extends Vehicle {
    public ElectricCar(String license) {
        super(license, VehicleType.ELECTRIC);
    }
}

// Spot base class and its derived classes
public abstract class ParkingSpot {
    private final String spotNumber;
    private final ParkingSpotType type;
    private boolean isFree;
    private Vehicle currentVehicle;

    public ParkingSpot(String spotNumber, ParkingSpotType type) {
        this.spotNumber = spotNumber;
        this.type = type;
        this.isFree = true;
    }

    public boolean isFree() {
        return isFree;
    }

    public void assignVehicle(Vehicle vehicle) {
        this.currentVehicle = vehicle;
        this.isFree = false;
    }

    public void removeVehicle() {
        this.currentVehicle = null;
        this.isFree = true;
    }

    public ParkingSpotType getType() {
        return type;
    }
}

public class CompactSpot extends ParkingSpot {
    public CompactSpot(String number) {
        super(number, ParkingSpotType.COMPACT);
    }
}

public class ElectricSpot extends ParkingSpot {
    private ElectricPanel panel;
    public ElectricSpot(String number, ElectricPanel panel) {
        super(number, ParkingSpotType.ELECTRIC);
        this.panel = panel;
    }

    public ElectricPanel getPanel() {
        return panel;
    }
}

// Ticket
public class Ticket {
    private final String ticketNumber;
    private final LocalDateTime entryTime;
    private LocalDateTime exitTime;
    private final ParkingSpot spot;
    private double amount;
    private boolean isPaid;

    public Ticket(String ticketNumber, ParkingSpot spot) {
        this.ticketNumber = ticketNumber;
        this.entryTime = LocalDateTime.now();
        this.spot = spot;
        this.isPaid = false;
    }

    public void markPaid(double amount) {
        this.amount = amount;
        this.isPaid = true;
        this.exitTime = LocalDateTime.now();
    }

    public ParkingSpot getSpot() {
        return spot;
    }

    public LocalDateTime getEntryTime() {
        return entryTime;
    }

    public LocalDateTime getExitTime() {
        return exitTime;
    }

    public boolean isPaid() {
        return isPaid;
    }
}

// Level / Floor
public class Level {
    private final int floorNumber;
    private final List<ParkingSpot> spots;
    private final ParkingDisplayBoard displayBoard;

    public Level(int floorNumber, List<ParkingSpot> spots, ParkingDisplayBoard board) {
        this.floorNumber = floorNumber;
        this.spots = spots;
        this.displayBoard = board;
    }

    public Ticket park(Vehicle vehicle) {
        for (ParkingSpot spot : spots) {
            if (spot.isFree() && isSpotCompatible(spot.getType(), vehicle.getType())) {
                spot.assignVehicle(vehicle);
                displayBoard.update(spot.getType(), false);
                return new Ticket(UUID.randomUUID().toString(), spot);
            }
        }
        return null;
    }

    private boolean isSpotCompatible(ParkingSpotType spotType, VehicleType vehicleType) {
        switch (vehicleType) {
            case MOTORCYCLE: return true;
            case CAR: return spotType == ParkingSpotType.COMPACT || spotType == ParkingSpotType.LARGE || spotType == ParkingSpotType.HANDICAPPED;
            case ELECTRIC: return spotType == ParkingSpotType.ELECTRIC;
            case TRUCK: return spotType == ParkingSpotType.LARGE;
            default: return false;
        }
    }
}

// Display Board
public class ParkingDisplayBoard {
    private final Map<ParkingSpotType, Integer> availableSpots;

    public ParkingDisplayBoard(Map<ParkingSpotType, Integer> initialSpots) {
        this.availableSpots = initialSpots;
    }

    public void update(ParkingSpotType type, boolean freed) {
        availableSpots.put(type, availableSpots.getOrDefault(type, 0) + (freed ? 1 : -1));
    }

    public void showStatus() {
        availableSpots.forEach((type, count) -> System.out.println(type + ": " + count));
    }
}

// Payment
public abstract class Payment {
    public abstract boolean pay(Ticket ticket);
}

public class CashPayment extends Payment {
    @Override
    public boolean pay(Ticket ticket) {
        ticket.markPaid(calculateFee(ticket));
        return true;
    }

    private double calculateFee(Ticket ticket) {
        return ParkingRate.getInstance().calculate(ticket.getEntryTime(), LocalDateTime.now());
    }
}

public class CreditCardPayment extends Payment {
    @Override
    public boolean pay(Ticket ticket) {
        ticket.markPaid(calculateFee(ticket));
        return true;
    }

    private double calculateFee(Ticket ticket) {
        return ParkingRate.getInstance().calculate(ticket.getEntryTime(), LocalDateTime.now());
    }
}

// Singleton ParkingLot
public class ParkingLot {
    private static final ParkingLot INSTANCE = new ParkingLot();
    private final List<Level> levels = new ArrayList<>();

    private ParkingLot() {}

    public static ParkingLot getInstance() {
        return INSTANCE;
    }

    public Ticket parkVehicle(Vehicle vehicle) {
        for (Level level : levels) {
            Ticket ticket = level.park(vehicle);
            if (ticket != null) return ticket;
        }
        return null;
    }

    public void unparkVehicle(Ticket ticket) {
        ticket.getSpot().removeVehicle();
    }

    public void addLevel(Level level) {
        levels.add(level);
    }
}

// Parking Rate
public class ParkingRate {
    private static final ParkingRate INSTANCE = new ParkingRate();
    private final List<Double> rates = List.of(4.0, 3.5, 3.5);

    private ParkingRate() {}

    public static ParkingRate getInstance() {
        return INSTANCE;
    }

    public double calculate(LocalDateTime entry, LocalDateTime exit) {
        long hours = Duration.between(entry, exit).toHours();
        double total = 0;
        for (int i = 0; i < hours; i++) {
            if (i < rates.size()) total += rates.get(i);
            else total += 2.5;
        }
        return total;
    }
}

// Electric Panel
public class ElectricPanel {
    public void chargeVehicle(Vehicle vehicle) {
        System.out.println("Charging electric vehicle: " + vehicle.getLicenseNumber());
    }
}

// Entry and Exit Panel
public class EntrancePanel {
    public Ticket issueTicket(Vehicle vehicle) {
        return ParkingLot.getInstance().parkVehicle(vehicle);
    }
}

public class ExitPanel {
    public boolean processPayment(Ticket ticket, Payment paymentMethod) {
        return paymentMethod.pay(ticket);
    }
}

// Customer Info Portal
public class CustomerInfoPortal {
    public boolean payTicket(Ticket ticket, Payment method) {
        return method.pay(ticket);
    }
}

// Demo class
public class ParkingLotDemo {
    public static void main(String[] args) throws InterruptedException {
        ElectricPanel electricPanel = new ElectricPanel();
        List<ParkingSpot> spots = new ArrayList<>();
        spots.add(new CompactSpot("C1"));
        spots.add(new ElectricSpot("E1", electricPanel));

        Map<ParkingSpotType, Integer> spotMap = new HashMap<>();
        spotMap.put(ParkingSpotType.COMPACT, 1);
        spotMap.put(ParkingSpotType.ELECTRIC, 1);

        ParkingDisplayBoard board = new ParkingDisplayBoard(spotMap);
        Level level = new Level(1, spots, board);

        ParkingLot.getInstance().addLevel(level);

        Vehicle car = new Car("KA-01-1234");
        EntrancePanel entrance = new EntrancePanel();
        Ticket ticket = entrance.issueTicket(car);

        if (ticket != null) {
            System.out.println("Vehicle parked at: " + ticket.getSpot().getType());
            Thread.sleep(2000); // simulate time spent

            Payment payment = new CreditCardPayment();
            ExitPanel exitPanel = new ExitPanel();
            if (exitPanel.processPayment(ticket, payment)) {
                System.out.println("Payment successful. Amount: " + ParkingRate.getInstance().calculate(ticket.getEntryTime(), ticket.getExitTime()));
                ParkingLot.getInstance().unparkVehicle(ticket);
            }
        } else {
            System.out.println("No spot available!");
        }
    }
}