// Sure! Below is the low-level design (LLD) code for a multi-floor parking lot system in Java. This design includes classes for ParkingLot, Floor, ParkingSpot, Vehicle, and more. The requirements considered are:

// Support for multiple floors.
// Different types of parking spots (e.g., compact, large, handicapped).
// Ability to park and unpark vehicles.
// Tracking available spots.
// Requirements:
// Multiple floors with a unique number of parking spots per floor.
// Each parking spot is of a specific type (e.g., compact, large, handicapped).
// Ability to park a vehicle and unpark a vehicle.
// Track the number of available parking spots.

// Explanation:
// Vehicle: Abstract class representing a vehicle. Concrete classes Motorcycle, Car, and Truck extend this.
// ParkingSpot: Represents a parking spot, tracks availability and the vehicle parked in it.
// Floor: Represents a floor in the parking lot with a list of parking spots.
// ParkingLot: Manages multiple floors and provides methods to park and unpark vehicles, as well as checking available spots.
// This design ensures encapsulation by declaring properties private and using public methods for access. This keeps the state of objects safe from unwanted changes and maintains control over the behavior of the system.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// Enum for vehicle type
enum VehicleType {
    MOTORCYCLE, CAR, TRUCK
}

// Enum for parking spot type
enum ParkingSpotType {
    COMPACT, LARGE, HANDICAPPED
}

// Abstract class for Vehicle
abstract class Vehicle {
    protected VehicleType type;
    protected String licensePlate;

    public VehicleType getType() {
        return type;
    }

    public String getLicensePlate() {
        return licensePlate;
    }
}

// Concrete classes for specific vehicle types
class Motorcycle extends Vehicle {
    public Motorcycle(String licensePlate) {
        this.type = VehicleType.MOTORCYCLE;
        this.licensePlate = licensePlate;
    }
}

class Car extends Vehicle {
    public Car(String licensePlate) {
        this.type = VehicleType.CAR;
        this.licensePlate = licensePlate;
    }
}

class Truck extends Vehicle {
    public Truck(String licensePlate) {
        this.type = VehicleType.TRUCK;
        this.licensePlate = licensePlate;
    }
}

// Class for ParkingSpot
class ParkingSpot {
    private final String id;
    private final ParkingSpotType type;
    private boolean isAvailable;
    private Vehicle currentVehicle;

    public ParkingSpot(String id, ParkingSpotType type) {
        this.id = id;
        this.type = type;
        this.isAvailable = true;
    }

    public String getId() {
        return id;
    }

    public ParkingSpotType getType() {
        return type;
    }

    public boolean isAvailable() {
        return isAvailable;
    }

    public boolean parkVehicle(Vehicle vehicle) {
        if (isAvailable) {
            this.currentVehicle = vehicle;
            this.isAvailable = false;
            return true;
        }
        return false;
    }

    public boolean unparkVehicle() {
        if (!isAvailable) {
            this.currentVehicle = null;
            this.isAvailable = true;
            return true;
        }
        return false;
    }

    public Vehicle getCurrentVehicle() {
        return currentVehicle;
    }
}

// Class for Floor
class Floor {
    private final int floorNumber;
    private final List<ParkingSpot> spots;

    public Floor(int floorNumber, int numberOfSpots) {
        this.floorNumber = floorNumber;
        this.spots = new ArrayList<>(numberOfSpots);
    }

    public int getFloorNumber() {
        return floorNumber;
    }

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

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

// Class for ParkingLot
class ParkingLot {
    private final String name;
    private final Map<Integer, Floor> floors;

    public ParkingLot(String name) {
        this.name = name;
        this.floors = new HashMap<>();
    }

    public void addFloor(Floor floor) {
        floors.put(floor.getFloorNumber(), floor);
    }

    public boolean parkVehicle(int floorNumber, Vehicle vehicle) {
        Floor floor = floors.get(floorNumber);
        if (floor == null) {
            return false;
        }

        for (ParkingSpot spot : floor.getSpots()) {
            if (spot.isAvailable() && isSpotSuitableForVehicle(spot, vehicle)) {
                return spot.parkVehicle(vehicle);
            }
        }
        return false;
    }

    public boolean unparkVehicle(int floorNumber, String licensePlate) {
        Floor floor = floors.get(floorNumber);
        if (floor == null) {
            return false;
        }

        for (ParkingSpot spot : floor.getSpots()) {
            if (!spot.isAvailable() && spot.getCurrentVehicle().getLicensePlate().equals(licensePlate)) {
                return spot.unparkVehicle();
            }
        }
        return false;
    }

    private boolean isSpotSuitableForVehicle(ParkingSpot spot, Vehicle vehicle) {
        switch (spot.getType()) {
            case COMPACT:
                return vehicle.getType() == VehicleType.MOTORCYCLE || vehicle.getType() == VehicleType.CAR;
            case LARGE:
                return true; // all types can fit in a large spot
            case HANDICAPPED:
                return vehicle.getType() == VehicleType.CAR || vehicle.getType() == VehicleType.TRUCK;
            default:
                return false;
        }
    }

    public int getAvailableSpots(int floorNumber) {
        Floor floor = floors.get(floorNumber);
        if (floor == null) {
            return 0;
        }

        int availableSpots = 0;
        for (ParkingSpot spot : floor.getSpots()) {
            if (spot.isAvailable()) {
                availableSpots++;
            }
        }
        return availableSpots;
    }
}

// Example usage
public class Main {
    public static void main(String[] args) {
        ParkingLot parkingLot = new ParkingLot("My Parking Lot");

        Floor floor1 = new Floor(1, 10);
        floor1.addParkingSpot(new ParkingSpot("1A", ParkingSpotType.COMPACT));
        floor1.addParkingSpot(new ParkingSpot("1B", ParkingSpotType.LARGE));
        floor1.addParkingSpot(new ParkingSpot("1C", ParkingSpotType.HANDICAPPED));
        parkingLot.addFloor(floor1);

        Floor floor2 = new Floor(2, 10);
        floor2.addParkingSpot(new ParkingSpot("2A", ParkingSpotType.COMPACT));
        floor2.addParkingSpot(new ParkingSpot("2B", ParkingSpotType.LARGE));
        floor2.addParkingSpot(new ParkingSpot("2C", ParkingSpotType.HANDICAPPED));
        parkingLot.addFloor(floor2);

        Vehicle car = new Car("CAR123");
        Vehicle motorcycle = new Motorcycle("MOTO123");

        parkingLot.parkVehicle(1, car);
        parkingLot.parkVehicle(2, motorcycle);

        System.out.println("Available spots on floor 1: " + parkingLot.getAvailableSpots(1));
        System.out.println("Available spots on floor 2: " + parkingLot.getAvailableSpots(2));

        parkingLot.unparkVehicle(1, "CAR123");
        parkingLot.unparkVehicle(2, "MOTO123");

        System.out.println("Available spots on floor 1 after unparking: " + parkingLot.getAvailableSpots(1));
        System.out.println("Available spots on floor 2 after unparking: " + parkingLot.getAvailableSpots(2));
    }
}