from abc import ABC, abstractmethod
from dataclasses import dataclass
from enum import Enum
import itertools
import threading


class VehicleType(Enum):
    MOTORCYCLE = 1
    CAR = 2
    TRUCK = 3


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


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


@dataclass(frozen=True)
class Money:
    paise: int
    def __str__(self) -> str: return f"Rs {self.paise / 100:.2f}"


class ParkingSpot:
    def __init__(self, spot_id: str, kind: SpotType):
        self.spot_id, self.kind = spot_id, kind
        self.vehicle: Vehicle | None = None

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

    def can_fit(self, vehicle: Vehicle) -> bool:
        return self.is_free and self.kind.value >= vehicle.kind.value

    def occupy(self, vehicle: Vehicle) -> None:
        if not self.can_fit(vehicle):
            raise ValueError(f"{self.spot_id} cannot take {vehicle.plate}")
        self.vehicle = vehicle

    def release(self) -> None: self.vehicle = None


class ParkingFloor:
    def __init__(self, number: int, spots: list[ParkingSpot]):
        self.number, self.spots = number, spots       # composition

    def free_spots(self, vehicle: Vehicle) -> list[ParkingSpot]:
        return [s for s in self.spots if s.can_fit(vehicle)]


@dataclass
class Ticket:
    ticket_id: str
    vehicle: Vehicle
    spot: ParkingSpot
    entry_minute: int
    exit_minute: int | None = None


# ---- extension point 1: where to put the vehicle ----------------------------
class SpotAllocationStrategy(ABC):
    @abstractmethod
    def allocate(self, floors: list[ParkingFloor], vehicle: Vehicle) -> ParkingSpot | None: ...

class FirstFit(SpotAllocationStrategy):
    def allocate(self, floors, vehicle):
        for floor in floors:
            free = floor.free_spots(vehicle)
            if free:
                return free[0]
        return None

class BestFit(SpotAllocationStrategy):
    """The smallest spot that still fits — keeps large spots free for large vehicles."""
    def allocate(self, floors, vehicle):
        candidates = [s for f in floors for s in f.free_spots(vehicle)]
        return min(candidates, key=lambda s: s.kind.value, default=None)


# ---- extension point 2: what to charge --------------------------------------
class PricingStrategy(ABC):
    @abstractmethod
    def price(self, minutes: int, kind: VehicleType) -> Money: ...

class PerHourPricing(PricingStrategy):
    RATES = {VehicleType.MOTORCYCLE: 2_000, VehicleType.CAR: 4_000, VehicleType.TRUCK: 8_000}
    def price(self, minutes, kind):
        hours = max(1, -(-minutes // 60))              # round part-hours up, minimum 1
        return Money(hours * self.RATES[kind])

class ProgressivePricing(PricingStrategy):
    """Cheap for the first hour, pricier each hour after — discourages long stays."""
    def price(self, minutes, kind):
        hours, total, rate = max(1, -(-minutes // 60)), 0, 2_000
        for _ in range(hours):
            total += rate
            rate += 1_000
        return Money(total)


class ParkingLot:
    """A facade: coordinates everything, hands every decision off to a collaborator."""

    def __init__(self, floors: list[ParkingFloor],
                 allocator: SpotAllocationStrategy,
                 pricing: PricingStrategy):
        self._floors, self._allocator, self._pricing = floors, allocator, pricing
        self._tickets: dict[str, Ticket] = {}
        self._ids = itertools.count(1)
        self._lock = threading.Lock()                  # guards allocation + the ticket book

    def park(self, vehicle: Vehicle, now_minute: int) -> Ticket:
        with self._lock:                               # find-and-occupy has to be one atomic step
            spot = self._allocator.allocate(self._floors, vehicle)
            if spot is None:
                raise RuntimeError(f"lot full for {vehicle.kind.name}")
            spot.occupy(vehicle)
            ticket = Ticket(f"T{next(self._ids)}", vehicle, spot, now_minute)
            self._tickets[ticket.ticket_id] = ticket
            return ticket

    def unpark(self, ticket_id: str, now_minute: int) -> Money:
        with self._lock:
            ticket = self._tickets.get(ticket_id)
            if ticket is None:
                raise ValueError("unknown ticket")
            if ticket.exit_minute is not None:
                raise ValueError("ticket already closed")   # stops charging someone twice
            ticket.exit_minute = now_minute
            ticket.spot.release()
            return self._pricing.price(now_minute - ticket.entry_minute, ticket.vehicle.kind)

    def availability(self) -> dict[SpotType, int]:
        with self._lock:
            counts = {t: 0 for t in SpotType}
            for floor in self._floors:
                for spot in floor.spots:
                    if spot.is_free:
                        counts[spot.kind] += 1
            return counts


def build_lot(allocator=None, pricing=None) -> ParkingLot:
    floors = [
        ParkingFloor(1, [ParkingSpot("1-S1", SpotType.SMALL),
                         ParkingSpot("1-M1", SpotType.MEDIUM),
                         ParkingSpot("1-L1", SpotType.LARGE)]),
        ParkingFloor(2, [ParkingSpot("2-M1", SpotType.MEDIUM)]),
    ]
    return ParkingLot(floors, allocator or BestFit(), pricing or PerHourPricing())


lot = build_lot()
bike = Vehicle("KA-01-1234", VehicleType.MOTORCYCLE)
car = Vehicle("KA-05-9999", VehicleType.CAR)
truck = Vehicle("KA-09-0001", VehicleType.TRUCK)

t_bike = lot.park(bike, now_minute=0)
assert t_bike.spot.spot_id == "1-S1"          # BestFit gives the bike the small spot

t_car = lot.park(car, now_minute=0)
assert t_car.spot.kind is SpotType.MEDIUM     # ...leaving the large spot free for the truck
t_truck = lot.park(truck, now_minute=0)
assert t_truck.spot.spot_id == "1-L1"

assert lot.unpark(t_bike.ticket_id, now_minute=90) == Money(4_000)   # 2 hours at Rs 20
try:
    lot.unpark(t_bike.ticket_id, now_minute=95)
    raise AssertionError("double exit allowed")
except ValueError:
    pass

progressive = build_lot(pricing=ProgressivePricing())
t = progressive.park(car, now_minute=0)
assert progressive.unpark(t.ticket_id, now_minute=180) == Money(2_000 + 3_000 + 4_000)

print("availability:", {k.name: v for k, v in lot.availability().items()})
print("bike fee:", Money(4_000), "| progressive 3h car:", Money(9_000))