Design a Parking Lot

from __future__ import annotations

import threading
from dataclasses import dataclass, replace
from datetime import datetime, timedelta
from enum import IntEnum
from typing import Callable, Protocol


class VehicleType(IntEnum):
    MOTORCYCLE = 0
    CAR = 1
    TRUCK = 2


class SpotSize(IntEnum):  # ordered: a bigger spot takes a smaller vehicle
    SMALL = 0
    MEDIUM = 1
    LARGE = 2


SIZE_FOR = {VehicleType.MOTORCYCLE: SpotSize.SMALL, VehicleType.CAR: SpotSize.MEDIUM,
            VehicleType.TRUCK: SpotSize.LARGE}


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


@dataclass
class Spot:
    id: str
    size: SpotSize
    plate: str = ""  # "" means free


@dataclass(frozen=True)  # frozen: callers can't flip a ticket to paid
class Ticket:
    id: str
    plate: str
    vehicle: VehicleType
    spot_id: str
    entry: datetime
    exit: datetime | None = None
    fee: int = 0
    paid: bool = False


class LotFull(Exception): ...
class AlreadyParked(Exception): ...
class UnknownTicket(Exception): ...
class TicketPaid(Exception): ...


class PricingStrategy(Protocol):
    def fee(self, v: VehicleType, stay: timedelta) -> int: ...


class HourlyPricing:
    def __init__(self, rates: dict[VehicleType, int]):
        self.rates = rates

    def fee(self, v: VehicleType, stay: timedelta) -> int:
        hours = max(1, -(-int(stay.total_seconds()) // 3600))  # round up, min 1
        return hours * self.rates[v]


class Level:
    def __init__(self, number: int, small: int, medium: int, large: int):
        sizes = [SpotSize.SMALL] * small + [SpotSize.MEDIUM] * medium + [SpotSize.LARGE] * large
        self.spots = [Spot(f"L{number}-S{i + 1}", s) for i, s in enumerate(sizes)]

    def find_spot(self, need: SpotSize) -> Spot | None:
        return next((s for s in self.spots if not s.plate and s.size >= need), None)


class Lot:
    def __init__(self, levels: list[Level], pricing: PricingStrategy,
                 now: Callable[[], datetime] = datetime.now):
        self._lock = threading.Lock()
        self._levels, self._pricing, self._now = levels, pricing, now
        self._spots = {s.id: s for lv in levels for s in lv.spots}
        self._tickets: dict[str, Ticket] = {}
        self._parked: dict[str, str] = {}  # plate -> ticket id
        self._next = 0

    def park(self, v: Vehicle) -> Ticket:
        if not v.plate:
            raise ValueError("vehicle needs a plate")
        with self._lock:
            if v.plate in self._parked:
                raise AlreadyParked("vehicle is already parked")
            for lv in self._levels:
                spot = lv.find_spot(SIZE_FOR[v.type])
                if spot:
                    spot.plate = v.plate
                    self._next += 1
                    t = Ticket(f"T{self._next:04d}", v.plate, v.type, spot.id, self._now())
                    self._tickets[t.id] = t
                    self._parked[v.plate] = t.id
                    return t
            raise LotFull("no free spot for this vehicle")

    def leave(self, ticket_id: str) -> Ticket:
        with self._lock:
            t = self._tickets.get(ticket_id)
            if t is None:
                raise UnknownTicket("unknown ticket")
            if t.paid:
                raise TicketPaid("ticket already paid")
            exit_at = self._now()
            t = replace(t, exit=exit_at, fee=self._pricing.fee(t.vehicle, exit_at - t.entry), paid=True)
            self._tickets[t.id] = t
            self._spots[t.spot_id].plate = ""
            del self._parked[t.plate]
            return t

    def free(self) -> dict[SpotSize, int]:
        with self._lock:
            out = {s: 0 for s in SpotSize}
            for s in self._spots.values():
                if not s.plate:
                    out[s.size] += 1
            return out


if __name__ == "__main__":
    clock = [datetime(2026, 11, 7, 9, 0)]
    lot = Lot([Level(1, 1, 2, 1), Level(2, 0, 1, 1)],
              HourlyPricing({VehicleType.MOTORCYCLE: 20, VehicleType.CAR: 50, VehicleType.TRUCK: 100}),
              now=lambda: clock[0])
    M, C, T = VehicleType.MOTORCYCLE, VehicleType.CAR, VehicleType.TRUCK
    tickets = {}
    for v in [Vehicle("BIKE-1", M), Vehicle("CAR-A", C), Vehicle("CAR-B", C), Vehicle("TRUCK-1", T),
              Vehicle("CAR-C", C), Vehicle("CAR-D", C), Vehicle("TRUCK-2", T)]:
        name = v.type.name.lower()
        try:
            t = lot.park(v)
            tickets[v.plate] = t.id
            print(f"{v.plate:<8} {name:<10} -> {t.spot_id} (ticket {t.id})")
        except LotFull as e:
            print(f"{v.plate:<8} {name:<10} -> {e}")

    clock[0] += timedelta(hours=2, minutes=30)
    t = lot.leave(tickets["CAR-A"])
    h, m = divmod(int((t.exit - t.entry).total_seconds()) // 60, 60)
    print(f"CAR-A left after {h}h{m}m0s, fee {t.fee} taka")
    try:
        lot.leave(tickets["CAR-A"])
    except TicketPaid as e:
        print("CAR-A again:", e)
    try:
        lot.park(Vehicle("TRUCK-2", T))
    except LotFull as e:
        print("TRUCK-2 retry ->", e)
    f = lot.free()
    print(f"free: small={f[SpotSize.SMALL]} medium={f[SpotSize.MEDIUM]} large={f[SpotSize.LARGE]}")

// Ordered sizes: a bigger spot takes a smaller vehicle.
const SIZES = ["small", "medium", "large"] as const;
type SpotSize = 0 | 1 | 2;
type VehicleType = "motorcycle" | "car" | "truck";
const SIZE_FOR: Record<VehicleType, SpotSize> = { motorcycle: 0, car: 1, truck: 2 };

interface Vehicle { readonly plate: string; readonly type: VehicleType }
interface Spot { readonly id: string; readonly size: SpotSize; plate: string } // "" = free

// Readonly: callers get a ticket they can't mark as paid themselves.
interface Ticket {
  readonly id: string; readonly plate: string; readonly vehicle: VehicleType;
  readonly spotId: string; readonly entry: Date;
  readonly exit?: Date; readonly fee: number; readonly paid: boolean;
}

interface PricingStrategy { fee(v: VehicleType, stayMs: number): number }

class HourlyPricing implements PricingStrategy {
  private readonly rates: Record<VehicleType, number>;
  constructor(rates: Record<VehicleType, number>) { this.rates = rates; }
  fee(v: VehicleType, stayMs: number): number {
    const hours = Math.max(1, Math.ceil(stayMs / 3_600_000));
    return hours * this.rates[v];
  }
}

class ParkingError extends Error {}

class Level {
  readonly spots: Spot[] = [];
  constructor(n: number, small: number, medium: number, large: number) {
    const sizes: SpotSize[] = [...Array(small).fill(0), ...Array(medium).fill(1), ...Array(large).fill(2)];
    sizes.forEach((size, i) => this.spots.push({ id: `L${n}-S${i + 1}`, size, plate: "" }));
  }
  findSpot(need: SpotSize): Spot | undefined {
    return this.spots.find((s) => !s.plate && s.size >= need);
  }
}

// No lock: JavaScript runs this code on one thread, and park() has no await inside,
// so two gates can't interleave in the middle of it.
class Lot {
  private readonly spots = new Map<string, Spot>();
  private readonly tickets = new Map<string, Ticket>();
  private readonly parked = new Map<string, string>(); // plate -> ticket id
  private next = 0;
  private readonly levels: Level[];
  private readonly pricing: PricingStrategy;
  private readonly now: () => Date;

  constructor(levels: Level[], pricing: PricingStrategy, now: () => Date = () => new Date()) {
    this.levels = levels; this.pricing = pricing; this.now = now;
    for (const lv of levels) for (const s of lv.spots) this.spots.set(s.id, s);
  }

  park(v: Vehicle): Ticket {
    if (!v.plate) throw new ParkingError("vehicle needs a plate");
    if (this.parked.has(v.plate)) throw new ParkingError("vehicle is already parked");
    for (const lv of this.levels) {
      const spot = lv.findSpot(SIZE_FOR[v.type]);
      if (!spot) continue;
      spot.plate = v.plate;
      const t: Ticket = {
        id: `T${String(++this.next).padStart(4, "0")}`, plate: v.plate, vehicle: v.type,
        spotId: spot.id, entry: this.now(), fee: 0, paid: false,
      };
      this.tickets.set(t.id, t);
      this.parked.set(v.plate, t.id);
      return t;
    }
    throw new ParkingError("no free spot for this vehicle");
  }

  leave(ticketId: string): Ticket {
    const t = this.tickets.get(ticketId);
    if (!t) throw new ParkingError("unknown ticket");
    if (t.paid) throw new ParkingError("ticket already paid");
    const exit = this.now();
    const done: Ticket = { ...t, exit, fee: this.pricing.fee(t.vehicle, exit.getTime() - t.entry.getTime()), paid: true };
    this.tickets.set(t.id, done);
    this.spots.get(t.spotId)!.plate = "";
    this.parked.delete(t.plate);
    return done;
  }

  free(): number[] {
    const out = [0, 0, 0];
    for (const s of this.spots.values()) if (!s.plate) out[s.size]++;
    return out;
  }
}

let clock = new Date(Date.UTC(2026, 10, 7, 9, 0));
const lot = new Lot(
  [new Level(1, 1, 2, 1), new Level(2, 0, 1, 1)],
  new HourlyPricing({ motorcycle: 20, car: 50, truck: 100 }),
  () => clock,
);
const tickets = new Map<string, string>();
const arrivals: Vehicle[] = [
  { plate: "BIKE-1", type: "motorcycle" }, { plate: "CAR-A", type: "car" }, { plate: "CAR-B", type: "car" },
  { plate: "TRUCK-1", type: "truck" }, { plate: "CAR-C", type: "car" }, { plate: "CAR-D", type: "car" },
  { plate: "TRUCK-2", type: "truck" },
];
for (const v of arrivals) {
  try {
    const t = lot.park(v);
    tickets.set(v.plate, t.id);
    console.log(`${v.plate.padEnd(8)} ${v.type.padEnd(10)} -> ${t.spotId} (ticket ${t.id})`);
  } catch (e) {
    console.log(`${v.plate.padEnd(8)} ${v.type.padEnd(10)} -> ${(e as Error).message}`);
  }
}
clock = new Date(clock.getTime() + 150 * 60_000);
const out = lot.leave(tickets.get("CAR-A")!);
const mins = (out.exit!.getTime() - out.entry.getTime()) / 60_000;
console.log(`CAR-A left after ${Math.floor(mins / 60)}h${mins % 60}m0s, fee ${out.fee} taka`);
try { lot.leave(tickets.get("CAR-A")!); } catch (e) { console.log("CAR-A again:", (e as Error).message); }
try { lot.park({ plate: "TRUCK-2", type: "truck" }); } catch (e) { console.log("TRUCK-2 retry ->", (e as Error).message); }
const f = lot.free();
console.log(`free: ${SIZES.map((s, i) => `${s}=${f[i]}`).join(" ")}`);

use std::collections::HashMap;
use std::fmt;
use std::sync::Mutex;

#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
enum VehicleType { Motorcycle, Car, Truck }

// Ordered: derive(PartialOrd) compares by declaration order, so Large > Small.
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
enum SpotSize { Small, Medium, Large }

impl VehicleType {
    fn needs(self) -> SpotSize {
        match self { Self::Motorcycle => SpotSize::Small, Self::Car => SpotSize::Medium, Self::Truck => SpotSize::Large }
    }
}
impl fmt::Display for VehicleType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let s = match self { Self::Motorcycle => "motorcycle", Self::Car => "car", Self::Truck => "truck" };
        f.pad(s) // pad() honours {:<10}
    }
}

struct Vehicle { plate: String, kind: VehicleType }
struct Spot { id: String, size: SpotSize, plate: Option<String> }

#[derive(Clone, Debug)] // callers get a clone, never a reference into the lot
struct Ticket { id: String, plate: String, vehicle: VehicleType, spot_id: String, entry: u64, exit: u64, fee: u32, paid: bool }

#[derive(Debug, PartialEq)]
enum ParkError { InvalidVehicle, LotFull, AlreadyParked, UnknownTicket, TicketPaid }
impl fmt::Display for ParkError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(match self {
            Self::InvalidVehicle => "vehicle needs a plate",
            Self::LotFull => "no free spot for this vehicle",
            Self::AlreadyParked => "vehicle is already parked",
            Self::UnknownTicket => "unknown ticket",
            Self::TicketPaid => "ticket already paid",
        })
    }
}

// Send + Sync so the lot can sit behind an Arc and be shared by gate threads.
trait PricingStrategy: Send + Sync { fn fee(&self, v: VehicleType, stay_secs: u64) -> u32; }

struct HourlyPricing { rates: HashMap<VehicleType, u32> }
impl PricingStrategy for HourlyPricing {
    fn fee(&self, v: VehicleType, stay_secs: u64) -> u32 {
        let hours = stay_secs.div_ceil(3600).max(1) as u32;
        hours * self.rates[&v]
    }
}

fn level(n: u32, small: usize, medium: usize, large: usize) -> Vec<Spot> {
    let sizes = [(small, SpotSize::Small), (medium, SpotSize::Medium), (large, SpotSize::Large)];
    sizes.iter().flat_map(|&(c, s)| std::iter::repeat_n(s, c)).enumerate()
        .map(|(i, size)| Spot { id: format!("L{n}-S{}", i + 1), size, plate: None }).collect()
}

// Everything that changes lives inside the Mutex, so the compiler won't let you touch
// a spot without holding the lock.
struct State { levels: Vec<Vec<Spot>>, tickets: HashMap<String, Ticket>, parked: HashMap<String, String>, next: u32 }

struct Lot { state: Mutex<State>, pricing: Box<dyn PricingStrategy>, now: Box<dyn Fn() -> u64 + Send + Sync> }

impl Lot {
    fn new(levels: Vec<Vec<Spot>>, pricing: Box<dyn PricingStrategy>, now: Box<dyn Fn() -> u64 + Send + Sync>) -> Self {
        Lot { state: Mutex::new(State { levels, tickets: HashMap::new(), parked: HashMap::new(), next: 0 }), pricing, now }
    }

    fn park(&self, v: &Vehicle) -> Result<Ticket, ParkError> {
        if v.plate.is_empty() { return Err(ParkError::InvalidVehicle); }
        let mut st = self.state.lock().unwrap();
        if st.parked.contains_key(&v.plate) { return Err(ParkError::AlreadyParked); }
        let need = v.kind.needs();
        let spot = st.levels.iter_mut().flatten()
            .find(|s| s.plate.is_none() && s.size >= need)
            .ok_or(ParkError::LotFull)?;
        spot.plate = Some(v.plate.clone());
        let spot_id = spot.id.clone();
        st.next += 1;
        let t = Ticket { id: format!("T{:04}", st.next), plate: v.plate.clone(), vehicle: v.kind, spot_id, entry: (self.now)(), exit: 0, fee: 0, paid: false };
        st.tickets.insert(t.id.clone(), t.clone());
        st.parked.insert(v.plate.clone(), t.id.clone());
        Ok(t)
    }

    fn leave(&self, ticket_id: &str) -> Result<Ticket, ParkError> {
        let mut st = self.state.lock().unwrap();
        let now = (self.now)();
        let t = st.tickets.get_mut(ticket_id).ok_or(ParkError::UnknownTicket)?;
        if t.paid { return Err(ParkError::TicketPaid); }
        t.exit = now;
        t.fee = self.pricing.fee(t.vehicle, t.exit - t.entry);
        t.paid = true;
        let done = t.clone();
        for s in st.levels.iter_mut().flatten() { if s.id == done.spot_id { s.plate = None; } }
        st.parked.remove(&done.plate);
        Ok(done)
    }

    fn free(&self) -> HashMap<SpotSize, usize> {
        let st = self.state.lock().unwrap();
        let mut out = HashMap::new();
        for s in st.levels.iter().flatten().filter(|s| s.plate.is_none()) { *out.entry(s.size).or_insert(0) += 1; }
        out
    }
}

fn main() {
    use std::sync::{atomic::{AtomicU64, Ordering}, Arc};
    let clock = Arc::new(AtomicU64::new(0)); // seconds since 09:00
    let c = clock.clone();
    let rates = HashMap::from([(VehicleType::Motorcycle, 20), (VehicleType::Car, 50), (VehicleType::Truck, 100)]);
    let lot = Lot::new(vec![level(1, 1, 2, 1), level(2, 0, 1, 1)], Box::new(HourlyPricing { rates }),
                       Box::new(move || c.load(Ordering::SeqCst)));

    let v = |p: &str, k| Vehicle { plate: p.to_string(), kind: k };
    use VehicleType::*;
    let arrivals = [v("BIKE-1", Motorcycle), v("CAR-A", Car), v("CAR-B", Car), v("TRUCK-1", Truck),
                    v("CAR-C", Car), v("CAR-D", Car), v("TRUCK-2", Truck)];
    let mut tickets = HashMap::new();
    for a in &arrivals {
        match lot.park(a) {
            Ok(t) => { println!("{:<8} {:<10} -> {} (ticket {})", a.plate, a.kind, t.spot_id, t.id); tickets.insert(a.plate.clone(), t.id); }
            Err(e) => println!("{:<8} {:<10} -> {}", a.plate, a.kind, e),
        }
    }
    clock.store(2 * 3600 + 30 * 60, Ordering::SeqCst);
    let t = lot.leave(&tickets["CAR-A"]).unwrap();
    let mins = (t.exit - t.entry) / 60;
    println!("CAR-A left after {}h{}m0s, fee {} taka", mins / 60, mins % 60, t.fee);
    if let Err(e) = lot.leave(&tickets["CAR-A"]) { println!("CAR-A again: {e}"); }
    if let Err(e) = lot.park(&v("TRUCK-2", Truck)) { println!("TRUCK-2 retry -> {e}"); }
    let f = lot.free();
    let n = |s| f.get(&s).copied().unwrap_or(0);
    println!("free: small={} medium={} large={}", n(SpotSize::Small), n(SpotSize::Medium), n(SpotSize::Large));
}

import java.time.Duration;
import java.time.Instant;
import java.util.*;
import java.util.function.Supplier;

public class Parking {
    enum VehicleType { MOTORCYCLE, CAR, TRUCK }

    // Ordered by declaration: compareTo says LARGE > SMALL.
    enum SpotSize { SMALL, MEDIUM, LARGE;
        static SpotSize forVehicle(VehicleType t) {
            return switch (t) { case MOTORCYCLE -> SMALL; case CAR -> MEDIUM; case TRUCK -> LARGE; };
        }
    }

    record Vehicle(String plate, VehicleType type) {}

    // A record is immutable: Leave returns a new ticket instead of changing the old one.
    record Ticket(String id, String plate, VehicleType vehicle, String spotId,
                  Instant entry, Instant exit, int fee, boolean paid) {}

    static final class Spot {
        final String id; final SpotSize size; String plate; // null = free
        Spot(String id, SpotSize size) { this.id = id; this.size = size; }
    }

    static class ParkingException extends RuntimeException {
        private static final long serialVersionUID = 1L;
        ParkingException(String msg) { super(msg); }
    }

    interface PricingStrategy { int fee(VehicleType v, Duration stay); }

    static final class HourlyPricing implements PricingStrategy {
        private final Map<VehicleType, Integer> rates;
        HourlyPricing(Map<VehicleType, Integer> rates) { this.rates = Map.copyOf(rates); }
        public int fee(VehicleType v, Duration stay) {
            long hours = Math.max(1, (stay.toSeconds() + 3599) / 3600);
            return (int) hours * rates.get(v);
        }
    }

    static final class Level {
        final List<Spot> spots = new ArrayList<>();
        Level(int n, int small, int medium, int large) {
            int i = 0;
            for (int k = 0; k < small; k++) spots.add(new Spot("L" + n + "-S" + ++i, SpotSize.SMALL));
            for (int k = 0; k < medium; k++) spots.add(new Spot("L" + n + "-S" + ++i, SpotSize.MEDIUM));
            for (int k = 0; k < large; k++) spots.add(new Spot("L" + n + "-S" + ++i, SpotSize.LARGE));
        }
        Optional<Spot> findSpot(SpotSize need) {
            return spots.stream().filter(s -> s.plate == null && s.size.compareTo(need) >= 0).findFirst();
        }
    }

    // synchronized methods share one lock: the object itself.
    static final class Lot {
        private final List<Level> levels;
        private final PricingStrategy pricing;
        private final Supplier<Instant> now;
        private final Map<String, Spot> spots = new HashMap<>();
        private final Map<String, Ticket> tickets = new HashMap<>();
        private final Map<String, String> parked = new HashMap<>(); // plate -> ticket id
        private int next = 0;

        Lot(List<Level> levels, PricingStrategy pricing, Supplier<Instant> now) {
            this.levels = List.copyOf(levels); this.pricing = pricing; this.now = now;
            for (Level lv : levels) for (Spot s : lv.spots) spots.put(s.id, s);
        }

        synchronized Ticket park(Vehicle v) {
            if (v.plate() == null || v.plate().isEmpty()) throw new IllegalArgumentException("vehicle needs a plate");
            if (parked.containsKey(v.plate())) throw new ParkingException("vehicle is already parked");
            SpotSize need = SpotSize.forVehicle(v.type());
            for (Level lv : levels) {
                Optional<Spot> found = lv.findSpot(need);
                if (found.isEmpty()) continue;
                Spot s = found.get();
                s.plate = v.plate();
                Ticket t = new Ticket(String.format("T%04d", ++next), v.plate(), v.type(), s.id, now.get(), null, 0, false);
                tickets.put(t.id(), t);
                parked.put(v.plate(), t.id());
                return t;
            }
            throw new ParkingException("no free spot for this vehicle");
        }

        synchronized Ticket leave(String ticketId) {
            Ticket t = tickets.get(ticketId);
            if (t == null) throw new ParkingException("unknown ticket");
            if (t.paid()) throw new ParkingException("ticket already paid");
            Instant exit = now.get();
            Ticket done = new Ticket(t.id(), t.plate(), t.vehicle(), t.spotId(), t.entry(), exit,
                    pricing.fee(t.vehicle(), Duration.between(t.entry(), exit)), true);
            tickets.put(done.id(), done);
            spots.get(done.spotId()).plate = null;
            parked.remove(done.plate());
            return done;
        }

        synchronized Map<SpotSize, Integer> free() {
            Map<SpotSize, Integer> out = new EnumMap<>(SpotSize.class);
            for (SpotSize s : SpotSize.values()) out.put(s, 0);
            for (Spot s : spots.values()) if (s.plate == null) out.merge(s.size, 1, Integer::sum);
            return out;
        }
    }

    public static void main(String[] args) {
        Instant[] clock = { Instant.parse("2026-11-07T09:00:00Z") };
        Lot lot = new Lot(List.of(new Level(1, 1, 2, 1), new Level(2, 0, 1, 1)),
                new HourlyPricing(Map.of(VehicleType.MOTORCYCLE, 20, VehicleType.CAR, 50, VehicleType.TRUCK, 100)),
                () -> clock[0]);
        var M = VehicleType.MOTORCYCLE; var C = VehicleType.CAR; var T = VehicleType.TRUCK;
        List<Vehicle> arrivals = List.of(new Vehicle("BIKE-1", M), new Vehicle("CAR-A", C), new Vehicle("CAR-B", C),
                new Vehicle("TRUCK-1", T), new Vehicle("CAR-C", C), new Vehicle("CAR-D", C), new Vehicle("TRUCK-2", T));
        Map<String, String> tickets = new HashMap<>();
        for (Vehicle v : arrivals) {
            String name = v.type().name().toLowerCase();
            try {
                Ticket t = lot.park(v);
                tickets.put(v.plate(), t.id());
                System.out.printf("%-8s %-10s -> %s (ticket %s)%n", v.plate(), name, t.spotId(), t.id());
            } catch (ParkingException e) {
                System.out.printf("%-8s %-10s -> %s%n", v.plate(), name, e.getMessage());
            }
        }
        clock[0] = clock[0].plus(Duration.ofMinutes(150));
        Ticket t = lot.leave(tickets.get("CAR-A"));
        long mins = Duration.between(t.entry(), t.exit()).toMinutes();
        System.out.printf("CAR-A left after %dh%dm0s, fee %d taka%n", mins / 60, mins % 60, t.fee());
        try { lot.leave(tickets.get("CAR-A")); } catch (ParkingException e) { System.out.println("CAR-A again: " + e.getMessage()); }
        try { lot.park(new Vehicle("TRUCK-2", T)); } catch (ParkingException e) { System.out.println("TRUCK-2 retry -> " + e.getMessage()); }
        var f = lot.free();
        System.out.printf("free: small=%d medium=%d large=%d%n", f.get(SpotSize.SMALL), f.get(SpotSize.MEDIUM), f.get(SpotSize.LARGE));
    }
}

#include <chrono>
#include <cstdio>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <optional>
#include <stdexcept>
#include <string>
#include <vector>

using Clock = std::function<std::chrono::minutes()>;  // minutes since opening

enum class VehicleType { Motorcycle, Car, Truck };
enum class SpotSize { Small, Medium, Large };  // enum class compares by value: Large > Small

const char* name(VehicleType t) {
    switch (t) {
        case VehicleType::Motorcycle: return "motorcycle";
        case VehicleType::Car: return "car";
        default: return "truck";
    }
}
SpotSize sizeFor(VehicleType t) {
    switch (t) {
        case VehicleType::Motorcycle: return SpotSize::Small;
        case VehicleType::Car: return SpotSize::Medium;
        default: return SpotSize::Large;
    }
}

struct Vehicle { std::string plate; VehicleType type; };
struct Spot { std::string id; SpotSize size; std::string plate; };  // "" = free

struct Ticket {
    std::string id, plate, spotId;
    VehicleType vehicle;
    std::chrono::minutes entry{}, exit{};
    int fee = 0;
    bool paid = false;
};

struct ParkingError : std::runtime_error { using std::runtime_error::runtime_error; };

struct PricingStrategy {
    virtual ~PricingStrategy() = default;
    virtual int fee(VehicleType v, std::chrono::minutes stay) const = 0;
};

struct HourlyPricing : PricingStrategy {
    std::map<VehicleType, int> rates;
    explicit HourlyPricing(std::map<VehicleType, int> r) : rates(std::move(r)) {}
    int fee(VehicleType v, std::chrono::minutes stay) const override {
        long hours = std::max<long>(1, (stay.count() + 59) / 60);
        return static_cast<int>(hours) * rates.at(v);
    }
};

struct Level {
    std::vector<Spot> spots;
    Level(int n, int small, int medium, int large) {
        int i = 0;
        auto add = [&](int count, SpotSize s) {
            for (int k = 0; k < count; ++k) spots.push_back({"L" + std::to_string(n) + "-S" + std::to_string(++i), s, ""});
        };
        add(small, SpotSize::Small); add(medium, SpotSize::Medium); add(large, SpotSize::Large);
    }
    Spot* findSpot(SpotSize need) {
        for (auto& s : spots) if (s.plate.empty() && s.size >= need) return &s;
        return nullptr;
    }
};

class Lot {
public:
    Lot(std::vector<Level> levels, std::unique_ptr<PricingStrategy> pricing, Clock now)
        : levels_(std::move(levels)), pricing_(std::move(pricing)), now_(std::move(now)) {}

    // Returns a copy: the caller can't reach into the lot's own ticket.
    Ticket park(const Vehicle& v) {
        if (v.plate.empty()) throw std::invalid_argument("vehicle needs a plate");
        std::lock_guard lock(mu_);  // RAII: unlocked on every return and throw
        if (parked_.count(v.plate)) throw ParkingError("vehicle is already parked");
        for (auto& lv : levels_) {
            Spot* s = lv.findSpot(sizeFor(v.type));
            if (!s) continue;
            s->plate = v.plate;
            char id[16];
            std::snprintf(id, sizeof id, "T%04d", ++next_);
            Ticket t{id, v.plate, s->id, v.type, now_()};
            tickets_[t.id] = t;
            parked_[v.plate] = t.id;
            return t;
        }
        throw ParkingError("no free spot for this vehicle");
    }

    Ticket leave(const std::string& ticketId) {
        std::lock_guard lock(mu_);
        auto it = tickets_.find(ticketId);
        if (it == tickets_.end()) throw ParkingError("unknown ticket");
        Ticket& t = it->second;
        if (t.paid) throw ParkingError("ticket already paid");
        t.exit = now_();
        t.fee = pricing_->fee(t.vehicle, t.exit - t.entry);
        t.paid = true;
        for (auto& lv : levels_) for (auto& s : lv.spots) if (s.id == t.spotId) s.plate.clear();
        parked_.erase(t.plate);
        return t;
    }

    std::map<SpotSize, int> free() {
        std::lock_guard lock(mu_);
        std::map<SpotSize, int> out{{SpotSize::Small, 0}, {SpotSize::Medium, 0}, {SpotSize::Large, 0}};
        for (auto& lv : levels_) for (auto& s : lv.spots) if (s.plate.empty()) ++out[s.size];
        return out;
    }

private:
    std::mutex mu_;
    std::vector<Level> levels_;
    std::unique_ptr<PricingStrategy> pricing_;
    Clock now_;
    std::map<std::string, Ticket> tickets_;
    std::map<std::string, std::string> parked_;  // plate -> ticket id
    int next_ = 0;
};

int main() {
    using namespace std::chrono_literals;
    std::chrono::minutes clock = 0min;
    Lot lot({Level(1, 1, 2, 1), Level(2, 0, 1, 1)},
            std::make_unique<HourlyPricing>(std::map<VehicleType, int>{
                {VehicleType::Motorcycle, 20}, {VehicleType::Car, 50}, {VehicleType::Truck, 100}}),
            [&] { return clock; });
    auto M = VehicleType::Motorcycle, C = VehicleType::Car, T = VehicleType::Truck;
    std::vector<Vehicle> arrivals{{"BIKE-1", M}, {"CAR-A", C}, {"CAR-B", C}, {"TRUCK-1", T},
                                  {"CAR-C", C}, {"CAR-D", C}, {"TRUCK-2", T}};
    std::map<std::string, std::string> tickets;
    for (auto& v : arrivals) {
        try {
            Ticket t = lot.park(v);
            tickets[v.plate] = t.id;
            std::printf("%-8s %-10s -> %s (ticket %s)\n", v.plate.c_str(), name(v.type), t.spotId.c_str(), t.id.c_str());
        } catch (const ParkingError& e) {
            std::printf("%-8s %-10s -> %s\n", v.plate.c_str(), name(v.type), e.what());
        }
    }
    clock += 150min;
    Ticket t = lot.leave(tickets["CAR-A"]);
    long mins = (t.exit - t.entry).count();
    std::printf("CAR-A left after %ldh%ldm0s, fee %d taka\n", mins / 60, mins % 60, t.fee);
    try { lot.leave(tickets["CAR-A"]); } catch (const ParkingError& e) { std::printf("CAR-A again: %s\n", e.what()); }
    try { lot.park({"TRUCK-2", T}); } catch (const ParkingError& e) { std::printf("TRUCK-2 retry -> %s\n", e.what()); }
    auto f = lot.free();
    std::printf("free: small=%d medium=%d large=%d\n", f[SpotSize::Small], f[SpotSize::Medium], f[SpotSize::Large]);
}