Design a Parking Lot.

# parking_lot.py, part 1: the vocabulary (enums and plain data)
from __future__ import annotations

import itertools
import math
import threading
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from enum import Enum


class VehicleType(Enum):
    BIKE = "bike"
    CAR = "car"
    TRUCK = "truck"


class SpotSize(Enum):
    SMALL = 1
    MEDIUM = 2
    LARGE = 3


# the smallest spot each vehicle fits in; anything larger also fits
MIN_SIZE = {VehicleType.BIKE: SpotSize.SMALL, VehicleType.CAR: SpotSize.MEDIUM, VehicleType.TRUCK: SpotSize.LARGE}


@dataclass(frozen=True)
class Vehicle:
    plate: str
    type: VehicleType


@dataclass
class ParkingSpot:
    spot_id: str
    floor: int
    size: SpotSize
    vehicle: Vehicle | None = None

    def is_free(self) -> bool:
        return self.vehicle is None

    def fits(self, v: Vehicle) -> bool:
        return self.size.value >= MIN_SIZE[v.type].value


@dataclass
class Floor:
    level: int
    spots: list[ParkingSpot] = field(default_factory=list)

    def free_count(self, size: SpotSize) -> int:
        return sum(1 for s in self.spots if s.size is size and s.is_free())


@dataclass(frozen=True)
class Ticket:
    ticket_id: str
    vehicle: Vehicle
    spot_id: str
    entry_at: datetime


@dataclass(frozen=True)
class Receipt:
    ticket_id: str
    hours: int
    amount: int  # rupees

# part 2: the two interfaces, and one implementation of each
class SpotAssignmentStrategy(ABC):
    @abstractmethod
    def find_spot(self, floors: list[Floor], vehicle: Vehicle) -> ParkingSpot | None: ...


class NearestSmallestFit(SpotAssignmentStrategy):
    """Lowest floor first; on a floor, the smallest spot that fits (keep large spots for trucks)."""

    def find_spot(self, floors: list[Floor], vehicle: Vehicle) -> ParkingSpot | None:
        for floor in sorted(floors, key=lambda f: f.level):
            fitting = [s for s in floor.spots if s.is_free() and s.fits(vehicle)]
            if fitting:
                return min(fitting, key=lambda s: (s.size.value, s.spot_id))
        return None


class PricingStrategy(ABC):
    @abstractmethod
    def price(self, ticket: Ticket, exit_at: datetime) -> Receipt: ...


class HourlyPricing(PricingStrategy):
    """Every started hour is billed; the minimum is one hour."""

    def __init__(self, rates: dict[VehicleType, int]) -> None:
        self.rates = rates

    def price(self, ticket: Ticket, exit_at: datetime) -> Receipt:
        seconds = max(0.0, (exit_at - ticket.entry_at).total_seconds())
        hours = max(1, math.ceil(seconds / 3600))
        return Receipt(ticket.ticket_id, hours, hours * self.rates[ticket.vehicle.type])

# part 3: the lot itself, the only class that changes state
class LotFullError(Exception): ...


class ParkingLot:
    def __init__(self, floors: list[Floor], assigner: SpotAssignmentStrategy, pricing: PricingStrategy) -> None:
        self.floors = floors
        self.assigner = assigner
        self.pricing = pricing
        self._spots = {s.spot_id: s for f in floors for s in f.spots}
        self._active: dict[str, Ticket] = {}  # ticket_id -> ticket
        self._parked: set[str] = set()  # plates inside right now
        self._ids = itertools.count(1)
        self._lock = threading.Lock()  # entry and exit gates call in on different threads

    def park(self, vehicle: Vehicle, at: datetime) -> Ticket:
        with self._lock:  # find + occupy must be one atomic step
            if vehicle.plate in self._parked:
                raise ValueError(f"{vehicle.plate} is already inside")
            spot = self.assigner.find_spot(self.floors, vehicle)
            if spot is None:
                raise LotFullError(f"no spot for a {vehicle.type.value}")
            spot.vehicle = vehicle
            ticket = Ticket(f"T{next(self._ids):04d}", vehicle, spot.spot_id, at)
            self._active[ticket.ticket_id] = ticket
            self._parked.add(vehicle.plate)
            return ticket

    def leave(self, ticket_id: str, at: datetime) -> Receipt:
        with self._lock:
            ticket = self._active.pop(ticket_id, None)
            if ticket is None:
                raise KeyError(f"unknown or already used ticket {ticket_id}")
            self._spots[ticket.spot_id].vehicle = None
            self._parked.discard(ticket.vehicle.plate)
        return self.pricing.price(ticket, at)  # pure, so it can run outside the lock

    def availability(self) -> dict[int, dict[str, int]]:
        with self._lock:
            return {f.level: {z.name: f.free_count(z) for z in SpotSize} for f in self.floors}

# part 4: build a small lot and drive it
def build_lot(levels: int, layout: dict[SpotSize, int]) -> ParkingLot:
    floors = []
    for lv in range(levels):
        spots = [ParkingSpot(f"F{lv}-{size.name[0]}{i}", lv, size) for size, n in layout.items() for i in range(n)]
        floors.append(Floor(lv, spots))
    rates = {VehicleType.BIKE: 20, VehicleType.CAR: 40, VehicleType.TRUCK: 100}
    return ParkingLot(floors, NearestSmallestFit(), HourlyPricing(rates))


if __name__ == "__main__":
    t0 = datetime(2026, 10, 25, 9, 0)
    lot = build_lot(2, {SpotSize.SMALL: 2, SpotSize.MEDIUM: 2, SpotSize.LARGE: 1})
    car = lot.park(Vehicle("KA01AB1234", VehicleType.CAR), t0)
    bike = lot.park(Vehicle("KA05XY9", VehicleType.BIKE), t0)
    truck = lot.park(Vehicle("MH12TR77", VehicleType.TRUCK), t0)
    print(car.spot_id, bike.spot_id, truck.spot_id)  # F0-M0 F0-S0 F0-L0
    print(lot.availability()[0])
    print(lot.leave(car.ticket_id, t0 + timedelta(hours=2, minutes=5)))  # 3 started hours: 120

    try:
        lot.leave(car.ticket_id, t0 + timedelta(hours=3))
    except KeyError as e:
        print("rejected:", e)

    # 40 cars race through the gates for 6 car-sized spots (2 floors x 2 medium + 1 large)
    lot2 = build_lot(2, {SpotSize.SMALL: 2, SpotSize.MEDIUM: 2, SpotSize.LARGE: 1})
    won: list[Ticket] = []

    def arrive(i: int) -> None:
        try:
            won.append(lot2.park(Vehicle(f"DL{i:04d}", VehicleType.CAR), t0))
        except LotFullError:
            pass

    threads = [threading.Thread(target=arrive, args=(i,)) for i in range(40)]
    for th in threads:
        th.start()
    for th in threads:
        th.join()
    spots = [t.spot_id for t in won]
    print(len(won), "parked,", len(set(spots)), "distinct spots")  # 6 parked, 6 distinct spots

F0-M0 F0-S0 F0-L0
{'SMALL': 1, 'MEDIUM': 1, 'LARGE': 0}
Receipt(ticket_id='T0001', hours=3, amount=120)
rejected: 'unknown or already used ticket T0001'
6 parked, 6 distinct spots