ParkingLot
 ├── ParkingFloor (Floor 1)
 │    ├── ParkingSpot (A1 - Small)
 │    ├── ParkingSpot (A2 - Medium)
 │    └── ...
 ├── ParkingFloor (Floor 2)
 │    ├── ParkingSpot (B1 - Large)
 │    └── ...
 └── ...

1ParkingSpot allocateSpot(List<ParkingFloor> floors, Vehicle vehicle);

1class VehicleSize(Enum):
2    SMALL = "SMALL"
3    MEDIUM = "MEDIUM"
4    LARGE = "LARGE"

1class Vehicle(ABC):
2    def __init__(self, license_number: str, size: VehicleSize):
3        self.license_number = license_number
4        self.size = size
5
6    def get_license_number(self) -> str:
7        return self.license_number
8
9    def get_size(self) -> VehicleSize:
10        return self.size
11
12class Bike(Vehicle):
13    def __init__(self, license_number: str):
14        super().__init__(license_number, VehicleSize.SMALL)
15
16
17class Car(Vehicle):
18    def __init__(self, license_number: str):
19        super().__init__(license_number, VehicleSize.MEDIUM)
20
21
22class Truck(Vehicle):
23    def __init__(self, license_number: str):
24        super().__init__(license_number, VehicleSize.LARGE)

1class ParkingSpot:
2    def __init__(self, spot_id: str, spot_size: VehicleSize):
3        self.spot_id = spot_id
4        self.spot_size = spot_size
5        self.is_occupied = False
6        self.parked_vehicle = None
7        self._lock = threading.Lock()
8
9    def get_spot_id(self) -> str:
10        return self.spot_id
11
12    def get_spot_size(self) -> VehicleSize:
13        return self.spot_size
14
15    def is_available(self) -> bool:
16        with self._lock:
17            return not self.is_occupied
18
19    def is_occupied_spot(self) -> bool:
20        return self.is_occupied
21
22    def park_vehicle(self, vehicle: Vehicle):
23        with self._lock:
24            self.parked_vehicle = vehicle
25            self.is_occupied = True
26
27    def unpark_vehicle(self):
28        with self._lock:
29            self.parked_vehicle = None
30            self.is_occupied = False
31
32    def can_fit_vehicle(self, vehicle: Vehicle) -> bool:
33        if self.is_occupied:
34            return False
35
36        if vehicle.get_size() == VehicleSize.SMALL:
37            return self.spot_size == VehicleSize.SMALL
38        elif vehicle.get_size() == VehicleSize.MEDIUM:
39            return self.spot_size == VehicleSize.MEDIUM or self.spot_size == VehicleSize.LARGE
40        elif vehicle.get_size() == VehicleSize.LARGE:
41            return self.spot_size == VehicleSize.LARGE
42        else:
43            return False

1class ParkingFloor:
2    def __init__(self, floor_number: int):
3        self.floor_number = floor_number
4        self.spots: Dict[str, ParkingSpot] = {}
5        self._lock = threading.Lock()
6
7    def add_spot(self, spot: ParkingSpot):
8        self.spots[spot.get_spot_id()] = spot
9
10    def find_available_spot(self, vehicle: Vehicle) -> Optional[ParkingSpot]:
11        with self._lock:
12            available_spots = [
13                spot for spot in self.spots.values()
14                if not spot.is_occupied_spot() and spot.can_fit_vehicle(vehicle)
15            ]
16            if available_spots:
17                # Sort by spot size (smallest first)
18                available_spots.sort(key=lambda x: x.get_spot_size().value)
19                return available_spots[0]
20            return None
21
22    def display_availability(self):
23        print(f"--- Floor {self.floor_number} Availability ---")
24        available_counts = defaultdict(int)
25        
26        for spot in self.spots.values():
27            if not spot.is_occupied_spot():
28                available_counts[spot.get_spot_size()] += 1
29
30        for size in VehicleSize:
31            print(f"  {size.value} spots: {available_counts[size]}")

1class ParkingTicket:
2    def __init__(self, vehicle: Vehicle, spot: ParkingSpot):
3        self.ticket_id = str(uuid.uuid4())
4        self.vehicle = vehicle
5        self.spot = spot
6        self.entry_timestamp = int(time.time() * 1000)
7        self.exit_timestamp = 0
8
9    def get_ticket_id(self) -> str:
10        return self.ticket_id
11
12    def get_vehicle(self) -> Vehicle:
13        return self.vehicle
14
15    def get_spot(self) -> ParkingSpot:
16        return self.spot
17
18    def get_entry_timestamp(self) -> int:
19        return self.entry_timestamp
20
21    def get_exit_timestamp(self) -> int:
22        return self.exit_timestamp
23
24    def set_exit_timestamp(self):
25        self.exit_timestamp = int(time.time() * 1000)
26

1class FeeStrategy(ABC):
2    @abstractmethod
3    def calculate_fee(self, parking_ticket: ParkingTicket) -> float:
4        pass
5
6class FlatRateFeeStrategy(FeeStrategy):
7    RATE_PER_HOUR = 10.0
8
9    def calculate_fee(self, parking_ticket: ParkingTicket) -> float:
10        duration = parking_ticket.get_exit_timestamp() - parking_ticket.get_entry_timestamp()
11        hours = (duration // (1000 * 60 * 60)) + 1
12        return hours * self.RATE_PER_HOUR
13
14class VehicleBasedFeeStrategy(FeeStrategy):
15    HOURLY_RATES = {
16        VehicleSize.SMALL: 10.0,
17        VehicleSize.MEDIUM: 20.0,
18        VehicleSize.LARGE: 30.0
19    }
20
21    def calculate_fee(self, parking_ticket: ParkingTicket) -> float:
22        duration = parking_ticket.get_exit_timestamp() - parking_ticket.get_entry_timestamp()
23        hours = (duration // (1000 * 60 * 60)) + 1
24        return hours * self.HOURLY_RATES[parking_ticket.get_vehicle().get_size()]

1class ParkingStrategy(ABC):
2    @abstractmethod
3    def find_spot(self, floors: List[ParkingFloor], vehicle: Vehicle) -> Optional[ParkingSpot]:
4        pass
5
6class NearestFirstStrategy(ParkingStrategy):
7    def find_spot(self, floors: List[ParkingFloor], vehicle: Vehicle) -> Optional[ParkingSpot]:
8        for floor in floors:
9            spot = floor.find_available_spot(vehicle)
10            if spot is not None:
11                return spot
12        return None
13
14class FarthestFirstStrategy(ParkingStrategy):
15    def find_spot(self, floors: List[ParkingFloor], vehicle: Vehicle) -> Optional[ParkingSpot]:
16        reversed_floors = list(reversed(floors))
17        for floor in reversed_floors:
18            spot = floor.find_available_spot(vehicle)
19            if spot is not None:
20                return spot
21        return None
22
23class BestFitStrategy(ParkingStrategy):
24    def find_spot(self, floors: List[ParkingFloor], vehicle: Vehicle) -> Optional[ParkingSpot]:
25        best_spot = None
26
27        for floor in floors:
28            spot_on_this_floor = floor.find_available_spot(vehicle)
29
30            if spot_on_this_floor is not None:
31                if best_spot is None:
32                    best_spot = spot_on_this_floor
33                else:
34                    # A smaller spot size enum ordinal means a tighter fit
35                    if list(VehicleSize).index(spot_on_this_floor.get_spot_size()) < list(VehicleSize).index(best_spot.get_spot_size()):
36                        best_spot = spot_on_this_floor
37
38        return best_spot

1class ParkingLot:
2    _instance = None
3    _lock = threading.Lock()
4
5    def __init__(self):
6        if ParkingLot._instance is not None:
7            raise Exception("This class is a singleton!")
8        self.floors: List[ParkingFloor] = []
9        self.active_tickets: Dict[str, ParkingTicket] = {}
10        self.fee_strategy = FlatRateFeeStrategy()
11        self.parking_strategy = NearestFirstStrategy()
12        self._main_lock = threading.Lock()
13
14    @staticmethod
15    def get_instance():
16        if ParkingLot._instance is None:
17            with ParkingLot._lock:
18                if ParkingLot._instance is None:
19                    ParkingLot._instance = ParkingLot()
20        return ParkingLot._instance
21
22    def add_floor(self, floor: ParkingFloor):
23        self.floors.append(floor)
24
25    def set_fee_strategy(self, fee_strategy: FeeStrategy):
26        self.fee_strategy = fee_strategy
27
28    def set_parking_strategy(self, parking_strategy: ParkingStrategy):
29        self.parking_strategy = parking_strategy
30
31    def park_vehicle(self, vehicle: Vehicle) -> Optional[ParkingTicket]:
32        with self._main_lock:
33            spot = self.parking_strategy.find_spot(self.floors, vehicle)
34            if spot is not None:
35                spot.park_vehicle(vehicle)
36                ticket = ParkingTicket(vehicle, spot)
37                self.active_tickets[vehicle.get_license_number()] = ticket
38                print(f"Vehicle {vehicle.get_license_number()} parked at spot {spot.get_spot_id()}")
39                return ticket
40            else:
41                print(f"No available spot for vehicle {vehicle.get_license_number()}")
42                return None
43
44    def unpark_vehicle(self, license_number: str) -> Optional[float]:
45        with self._main_lock:
46            ticket = self.active_tickets.pop(license_number, None)
47            if ticket is None:
48                print(f"Ticket not found for vehicle {license_number}")
49                return None
50
51            ticket.get_spot().unpark_vehicle()
52            ticket.set_exit_timestamp()
53            fee = self.fee_strategy.calculate_fee(ticket)
54            print(f"Vehicle {license_number} unparked from spot {ticket.get_spot().get_spot_id()}")
55            return fee

1class ParkingLotDemo:
2    @staticmethod
3    def main():
4        parking_lot = ParkingLot.get_instance()
5
6        # 1. Initialize the parking lot with floors and spots
7        floor1 = ParkingFloor(1)
8        floor1.add_spot(ParkingSpot("F1-S1", VehicleSize.SMALL))
9        floor1.add_spot(ParkingSpot("F1-M1", VehicleSize.MEDIUM))
10        floor1.add_spot(ParkingSpot("F1-L1", VehicleSize.LARGE))
11
12        floor2 = ParkingFloor(2)
13        floor2.add_spot(ParkingSpot("F2-M1", VehicleSize.MEDIUM))
14        floor2.add_spot(ParkingSpot("F2-M2", VehicleSize.MEDIUM))
15
16        parking_lot.add_floor(floor1)
17        parking_lot.add_floor(floor2)
18
19        parking_lot.set_fee_strategy(VehicleBasedFeeStrategy())
20
21        # 2. Simulate vehicle entries
22        print("\n--- Vehicle Entries ---")
23        floor1.display_availability()
24        floor2.display_availability()
25
26        bike = Bike("B-123")
27        car = Car("C-456")
28        truck = Truck("T-789")
29
30        bike_ticket = parking_lot.park_vehicle(bike)
31        car_ticket = parking_lot.park_vehicle(car)
32        truck_ticket = parking_lot.park_vehicle(truck)
33
34        print("\n--- Availability after parking ---")
35        floor1.display_availability()
36        floor2.display_availability()
37
38        # 3. Simulate another car entry (should go to floor 2)
39        car2 = Car("C-999")
40        car2_ticket = parking_lot.park_vehicle(car2)
41
42        # 4. Simulate a vehicle entry that fails (no available spots)
43        bike2 = Bike("B-000")
44        failed_bike_ticket = parking_lot.park_vehicle(bike2)
45
46        # 5. Simulate vehicle exits and fee calculation
47        print("\n--- Vehicle Exits ---")
48
49        if car_ticket is not None:
50            fee = parking_lot.unpark_vehicle(car.get_license_number())
51            if fee is not None:
52                print(f"Car C-456 unparked. Fee: ${fee:.2f}")
53
54        print("\n--- Availability after one car leaves ---")
55        floor1.display_availability()
56        floor2.display_availability()
57
58
59if __name__ == "__main__":
60    ParkingLotDemo.main()