1. Parking Lot Intermediate → Advanced+Concurrency

class ParkingLot {
  Ticket parkVehicle(Vehicle vehicle);          // throws NoAvailableSpotException
  Fee    unparkVehicle(Ticket ticket);          // throws InvalidTicketException
}

interface SpotAllocator {
  ParkingSpot allocate(VehicleSize size);       // returns null / throws if none available
}

interface FeeStrategy {
  Money calculate(Ticket closedTicket);
}

class ParkingSpot {
  boolean canFit(VehicleSize size);
  void    occupy(Vehicle vehicle);              // throws IllegalStateException if already occupied
  void    vacate();
}

class ParkingLot {
  Ticket parkVehicle(Vehicle vehicle) throws NoAvailableSpotException { throw new UnsupportedOperationException(); }
  Fee unparkVehicle(Ticket ticket) throws InvalidTicketException { throw new UnsupportedOperationException(); }
}

interface SpotAllocator {
  Optional<ParkingSpot> allocate(VehicleSize size);   // returns Optional.empty() / throws if none available
}

interface FeeStrategy {
  Money calculate(Ticket closedTicket);
}

class ParkingSpot {
  boolean canFit(VehicleSize size) { throw new UnsupportedOperationException(); }
  void occupy(Vehicle vehicle) { throw new UnsupportedOperationException(); }   // throws IllegalStateException if already occupied
  void vacate() { throw new UnsupportedOperationException(); }
}

class ParkingLot {
public:
  std::shared_ptr<Ticket> parkVehicle(std::shared_ptr<Vehicle> vehicle);   // throws NoAvailableSpotException
  Fee unparkVehicle(std::shared_ptr<Ticket> ticket);                       // throws InvalidTicketException
};

class SpotAllocator {
public:
  virtual std::optional<ParkingSpot> allocate(VehicleSize size) = 0;   // returns nullopt / throws if none available
};

class FeeStrategy {
public:
  virtual Money calculate(std::shared_ptr<Ticket> closedTicket) = 0;
};

class ParkingSpot {
public:
  bool canFit(VehicleSize size);
  void occupy(std::shared_ptr<Vehicle> vehicle);   // throws std::logic_error if already occupied
  void vacate();
};

class ParkingLot {
  parkVehicle(vehicle) { throw new Error('not implemented'); }   // throws NoAvailableSpotException
  unparkVehicle(ticket) { throw new Error('not implemented'); }  // throws InvalidTicketException
}

class SpotAllocator {
  allocate(size) { throw new Error('not implemented'); }   // returns null / throws if none available
}

class FeeStrategy {
  calculate(closedTicket) { throw new Error('not implemented'); }
}

class ParkingSpot {
  canFit(size) { throw new Error('not implemented'); }
  occupy(vehicle) { throw new Error('not implemented'); }   // throws Error if already occupied
  vacate() { throw new Error('not implemented'); }
}

class ParkingLot {
  parkVehicle(vehicle: Vehicle): Ticket { throw new Error('not implemented'); }   // throws NoAvailableSpotException
  unparkVehicle(ticket: Ticket): Fee { throw new Error('not implemented'); }      // throws InvalidTicketException
}

interface SpotAllocator {
  allocate(size: VehicleSize): ParkingSpot | null;   // returns null / throws if none available
}

interface FeeStrategy {
  calculate(closedTicket: Ticket): Money;
}

class ParkingSpot {
  canFit(size: VehicleSize): boolean { throw new Error('not implemented'); }
  occupy(vehicle: Vehicle): void { throw new Error('not implemented'); }   // throws Error if already occupied
  vacate(): void { throw new Error('not implemented'); }
}

park(vehicle):
  size = vehicle.getSize()
  spot = allocator.allocate(size)          // must be atomic — see W. Concurrency
  if spot is null: raise NoAvailableSpotException
  spot.occupy(vehicle)
  ticket = Ticket.create(vehicle, spot, now())
  return ticket

unpark(ticket):
  if ticket.status != ACTIVE: raise InvalidTicketException
  ticket.close(now())
  fee = feeStrategy.calculate(ticket)
  ticket.spot.vacate()
  return fee

Ticket park(Vehicle vehicle) throws NoAvailableSpotException {   // custom checked exception
  VehicleSize size = vehicle.getSize();
  Optional<ParkingSpot> spot = allocator.allocate(size);   // must be atomic — see W. Concurrency
  if (spot.isEmpty()) throw new NoAvailableSpotException();
  spot.get().occupy(vehicle);
  Ticket ticket = Ticket.create(vehicle, spot.get(), now());
  return ticket;
}

Fee unpark(Ticket ticket) throws InvalidTicketException {   // custom checked exception
  if (ticket.status != ACTIVE) throw new InvalidTicketException();
  ticket.close(now());
  Fee fee = feeStrategy.calculate(ticket);
  ticket.spot.vacate();
  return fee;
}

std::shared_ptr<Ticket> park(std::shared_ptr<Vehicle> vehicle) {
  VehicleSize size = vehicle->getSize();
  std::optional<ParkingSpot> spot = allocator.allocate(size);   // must be atomic — see W. Concurrency
  if (!spot.has_value()) throw NoAvailableSpotException();
  spot->occupy(vehicle);
  auto ticket = Ticket::create(vehicle, *spot, now());
  return ticket;
}

Fee unpark(std::shared_ptr<Ticket> ticket) {
  if (ticket->status != ACTIVE) throw InvalidTicketException();
  ticket->close(now());
  Fee fee = feeStrategy.calculate(ticket);
  ticket->spot.vacate();
  return fee;
}

function park(vehicle) {
  const size = vehicle.getSize();
  const spot = allocator.allocate(size);        // must be atomic — see W. Concurrency
  if (spot === null) throw new Error('NoAvailableSpotException');
  spot.occupy(vehicle);
  const ticket = Ticket.create(vehicle, spot, now());
  return ticket;
}

function unpark(ticket) {
  if (ticket.status !== ACTIVE) throw new Error('InvalidTicketException');
  ticket.close(now());
  const fee = feeStrategy.calculate(ticket);
  ticket.spot.vacate();
  return fee;
}

function park(vehicle: Vehicle): Ticket {
  const size: VehicleSize = vehicle.getSize();
  const spot: ParkingSpot | null = allocator.allocate(size);   // must be atomic — see W. Concurrency
  if (spot === null) throw new Error('NoAvailableSpotException');
  spot.occupy(vehicle);
  const ticket: Ticket = Ticket.create(vehicle, spot, now());
  return ticket;
}

function unpark(ticket: Ticket): Fee {
  if (ticket.status !== ACTIVE) throw new Error('InvalidTicketException');
  ticket.close(now());
  const fee: Fee = feeStrategy.calculate(ticket);
  ticket.spot.vacate();
  return fee;
}

// Parking Lot - full LLD implementation (single-file demo).
// Difficulty badge includes "Concurrency", so spot allocation + occupation is guarded
// by a lock to guarantee two concurrent parkVehicle() calls never get the same spot.
import java.util.*;
import java.util.concurrent.locks.*;

public class p1 {

    // ---------- Vehicle hierarchy ----------
    enum VehicleSize { MOTORCYCLE, COMPACT, LARGE }

    static abstract class Vehicle {
        private final String licensePlate;
        Vehicle(String licensePlate) { this.licensePlate = licensePlate; }
        String getLicensePlate() { return licensePlate; }
        abstract VehicleSize getSize();
    }

    static class Motorcycle extends Vehicle {
        Motorcycle(String plate) { super(plate); }
        VehicleSize getSize() { return VehicleSize.MOTORCYCLE; }
    }

    static class Car extends Vehicle {
        Car(String plate) { super(plate); }
        VehicleSize getSize() { return VehicleSize.COMPACT; }
    }

    static class Bus extends Vehicle {
        Bus(String plate) { super(plate); }
        VehicleSize getSize() { return VehicleSize.LARGE; }
    }

    // ---------- ParkingSpot ----------
    static class ParkingSpot {
        private final String id;
        private final VehicleSize size;
        private boolean occupied = false;
        private Vehicle currentVehicle;

        ParkingSpot(String id, VehicleSize size) { this.id = id; this.size = size; }

        String getId() { return id; }
        VehicleSize getSize() { return size; }
        boolean isOccupied() { return occupied; }

        // A larger spot can host a smaller vehicle; ordinal() works because the enum
        // is declared smallest-to-largest.
        boolean canFit(VehicleSize vehicleSize) { return !occupied && size.ordinal() >= vehicleSize.ordinal(); }

        void occupy(Vehicle vehicle) {
            if (occupied) throw new IllegalStateException("Spot " + id + " already occupied");
            occupied = true;
            currentVehicle = vehicle;
        }

        void vacate() {
            occupied = false;
            currentVehicle = null;
        }
    }

    // ---------- Floor ----------
    static class Floor {
        private final int floorNumber;
        private final List<ParkingSpot> spots;

        Floor(int floorNumber, List<ParkingSpot> spots) {
            this.floorNumber = floorNumber;
            this.spots = spots;
        }

        int getFloorNumber() { return floorNumber; }
        List<ParkingSpot> getSpots() { return spots; }

        // First compatible free spot on this floor, or null if none.
        ParkingSpot findAvailableSpot(VehicleSize size) {
            for (ParkingSpot s : spots) {
                if (s.canFit(size)) return s;
            }
            return null;
        }
    }

    // ---------- SpotAllocator (interface) + strategies ----------
    interface SpotAllocator {
        ParkingSpot allocate(Vehicle vehicle);
    }

    // Picks the first free compatible spot, scanning floors in order.
    static class FirstAvailableAllocator implements SpotAllocator {
        private final List<Floor> floors;
        FirstAvailableAllocator(List<Floor> floors) { this.floors = floors; }
        public ParkingSpot allocate(Vehicle vehicle) {
            for (Floor f : floors) {
                ParkingSpot spot = f.findAvailableSpot(vehicle.getSize());
                if (spot != null) return spot;
            }
            return null;
        }
    }

    // Picks the compatible spot whose size is the closest fit (least wasted space),
    // scanning floors in order and comparing candidates across floors.
    static class NearestSpotAllocator implements SpotAllocator {
        private final List<Floor> floors;
        NearestSpotAllocator(List<Floor> floors) { this.floors = floors; }
        public ParkingSpot allocate(Vehicle vehicle) {
            ParkingSpot best = null;
            for (Floor f : floors) {
                for (ParkingSpot s : f.getSpots()) {
                    if (!s.canFit(vehicle.getSize())) continue;
                    if (best == null || s.getSize().ordinal() < best.getSize().ordinal()) best = s;
                }
            }
            return best;
        }
    }

    // ---------- Ticket ----------
    enum TicketStatus { ACTIVE, CLOSED }

    static class Ticket {
        private static int SEQ = 1;
        private final String id;
        private final Vehicle vehicle;
        private final ParkingSpot spot;
        private final long entryTime;
        private long exitTime;
        private TicketStatus status;

        private Ticket(Vehicle vehicle, ParkingSpot spot, long entryTime) {
            this.id = "T-" + (SEQ++);
            this.vehicle = vehicle;
            this.spot = spot;
            this.entryTime = entryTime;
            this.status = TicketStatus.ACTIVE;
        }

        static Ticket create(Vehicle vehicle, ParkingSpot spot, long entryTime) {
            return new Ticket(vehicle, spot, entryTime);
        }

        void close(long exitTime) {
            this.exitTime = exitTime;
            this.status = TicketStatus.CLOSED;
        }

        String getId() { return id; }
        Vehicle getVehicle() { return vehicle; }
        ParkingSpot getSpot() { return spot; }
        long getEntryTime() { return entryTime; }
        long getExitTime() { return exitTime; }
        TicketStatus getStatus() { return status; }
    }

    // ---------- FeeStrategy (interface) + strategies ----------
    interface FeeStrategy {
        double calculate(Ticket closedTicket);
    }

    static class HourlyFeeStrategy implements FeeStrategy {
        private final double ratePerHour;
        HourlyFeeStrategy(double ratePerHour) { this.ratePerHour = ratePerHour; }
        public double calculate(Ticket t) {
            long durationMs = t.getExitTime() - t.getEntryTime();
            double hours = Math.max(1, Math.ceil(durationMs / 3600000.0)); // round up, min 1 hour
            return hours * ratePerHour;
        }
    }

    // Applies a surcharge multiplier if entry happened during peak hours (9-11, 17-19).
    static class PeakHourFeeStrategy implements FeeStrategy {
        private final double ratePerHour;
        private final double peakMultiplier;
        PeakHourFeeStrategy(double ratePerHour, double peakMultiplier) {
            this.ratePerHour = ratePerHour;
            this.peakMultiplier = peakMultiplier;
        }
        public double calculate(Ticket t) {
            long durationMs = t.getExitTime() - t.getEntryTime();
            double hours = Math.max(1, Math.ceil(durationMs / 3600000.0));
            int entryHour = (int) ((t.getEntryTime() / 3600000) % 24);
            boolean peak = (entryHour >= 9 && entryHour < 11) || (entryHour >= 17 && entryHour < 19);
            return hours * ratePerHour * (peak ? peakMultiplier : 1.0);
        }
    }

    // ---------- Exceptions ----------
    static class NoAvailableSpotException extends RuntimeException {
        NoAvailableSpotException(String msg) { super(msg); }
    }
    static class InvalidTicketException extends RuntimeException {
        InvalidTicketException(String msg) { super(msg); }
    }

    // ---------- ParkingLot (facade) ----------
    static class ParkingLot {
        private final List<Floor> floors;
        private final SpotAllocator allocator;   // injected interface, not a concrete class
        private final FeeStrategy feeStrategy;    // injected interface, not a concrete class
        // Single lock guarding the "decide spot + occupy spot" sequence, which spans two
        // separate objects (allocator, spot) and therefore cannot be made atomic by either
        // object alone.
        private final Lock lock = new ReentrantLock();

        ParkingLot(List<Floor> floors, SpotAllocator allocator, FeeStrategy feeStrategy) {
            this.floors = floors;
            this.allocator = allocator;
            this.feeStrategy = feeStrategy;
        }

        Ticket parkVehicle(Vehicle vehicle) {
            lock.lock();
            try {
                ParkingSpot spot = allocator.allocate(vehicle);
                if (spot == null) throw new NoAvailableSpotException("No available spot for " + vehicle.getSize());
                spot.occupy(vehicle);
                return Ticket.create(vehicle, spot, System.currentTimeMillis());
            } finally {
                lock.unlock();
            }
        }

        double unparkVehicle(Ticket ticket) {
            lock.lock();
            try {
                if (ticket.getStatus() != TicketStatus.ACTIVE) throw new InvalidTicketException("Ticket not active: " + ticket.getId());
                ticket.close(System.currentTimeMillis());
                double fee = feeStrategy.calculate(ticket);
                ticket.getSpot().vacate();
                return fee;
            } finally {
                lock.unlock();
            }
        }
    }

    // ---------- Demo ----------
    public static void main(String[] args) {
        List<ParkingSpot> f1Spots = Arrays.asList(
                new ParkingSpot("F1-M1", VehicleSize.MOTORCYCLE),
                new ParkingSpot("F1-C1", VehicleSize.COMPACT)
        );
        Floor floor1 = new Floor(1, f1Spots);
        List<Floor> floors = new ArrayList<>(Collections.singletonList(floor1));

        SpotAllocator allocator = new NearestSpotAllocator(floors);
        FeeStrategy feeStrategy = new HourlyFeeStrategy(10.0);
        ParkingLot lot = new ParkingLot(floors, allocator, feeStrategy);

        Car car = new Car("KA-01-1234");
        Ticket t1 = lot.parkVehicle(car);
        System.out.println("Parked car, ticket=" + t1.getId() + " spot=" + t1.getSpot().getId());

        Motorcycle bike = new Motorcycle("KA-01-5678");
        Ticket t2 = lot.parkVehicle(bike);
        System.out.println("Parked bike, ticket=" + t2.getId() + " spot=" + t2.getSpot().getId());

        try {
            Bus bus = new Bus("KA-01-9999");
            lot.parkVehicle(bus); // no LARGE spot exists -> should fail
        } catch (NoAvailableSpotException e) {
            System.out.println("Expected failure parking bus: " + e.getMessage());
        }

        double fee = lot.unparkVehicle(t1);
        System.out.println("Unparked car, fee=" + fee);
    }
}

// Parking Lot - full LLD implementation (single-file demo).
// Difficulty badge includes "Concurrency", so spot allocation + occupation is guarded
// by a mutex to guarantee two concurrent parkVehicle() calls never get the same spot.
#include <iostream>
#include <vector>
#include <memory>
#include <string>
#include <mutex>
#include <stdexcept>
#include <chrono>
#include <cmath>

// ---------- Vehicle hierarchy ----------
enum class VehicleSize { MOTORCYCLE = 0, COMPACT = 1, LARGE = 2 };

class Vehicle {
public:
    Vehicle(std::string plate) : licensePlate(std::move(plate)) {}
    virtual ~Vehicle() = default;
    const std::string& getLicensePlate() const { return licensePlate; }
    virtual VehicleSize getSize() const = 0;
private:
    std::string licensePlate;
};

class Motorcycle : public Vehicle {
public:
    explicit Motorcycle(std::string plate) : Vehicle(std::move(plate)) {}
    VehicleSize getSize() const override { return VehicleSize::MOTORCYCLE; }
};

class Car : public Vehicle {
public:
    explicit Car(std::string plate) : Vehicle(std::move(plate)) {}
    VehicleSize getSize() const override { return VehicleSize::COMPACT; }
};

class Bus : public Vehicle {
public:
    explicit Bus(std::string plate) : Vehicle(std::move(plate)) {}
    VehicleSize getSize() const override { return VehicleSize::LARGE; }
};

// ---------- ParkingSpot ----------
class ParkingSpot {
public:
    ParkingSpot(std::string id, VehicleSize size) : id(std::move(id)), size(size) {}

    const std::string& getId() const { return id; }
    VehicleSize getSize() const { return size; }
    bool isOccupied() const { return occupied; }

    // A larger spot can host a smaller vehicle; enum values are ordered smallest-to-largest.
    bool canFit(VehicleSize vehicleSize) const {
        return !occupied && static_cast<int>(size) >= static_cast<int>(vehicleSize);
    }

    void occupy(Vehicle* vehicle) {
        if (occupied) throw std::runtime_error("Spot " + id + " already occupied");
        occupied = true;
        currentVehicle = vehicle;
    }

    void vacate() {
        occupied = false;
        currentVehicle = nullptr;
    }

private:
    std::string id;
    VehicleSize size;
    bool occupied = false;
    Vehicle* currentVehicle = nullptr;
};

// ---------- Floor ----------
class Floor {
public:
    Floor(int floorNumber, std::vector<std::unique_ptr<ParkingSpot>> spots)
        : floorNumber(floorNumber), spots(std::move(spots)) {}

    int getFloorNumber() const { return floorNumber; }
    std::vector<std::unique_ptr<ParkingSpot>>& getSpots() { return spots; }

    // First compatible free spot on this floor, or nullptr if none.
    ParkingSpot* findAvailableSpot(VehicleSize size) {
        for (auto& s : spots) {
            if (s->canFit(size)) return s.get();
        }
        return nullptr;
    }

private:
    int floorNumber;
    std::vector<std::unique_ptr<ParkingSpot>> spots;
};

// ---------- Ticket ----------
enum class TicketStatus { ACTIVE, CLOSED };

class Ticket {
public:
    static std::unique_ptr<Ticket> create(Vehicle* vehicle, ParkingSpot* spot, long long entryTime) {
        return std::unique_ptr<Ticket>(new Ticket(vehicle, spot, entryTime));
    }

    void close(long long exit) { exitTime = exit; status = TicketStatus::CLOSED; }

    const std::string& getId() const { return id; }
    Vehicle* getVehicle() const { return vehicle; }
    ParkingSpot* getSpot() const { return spot; }
    long long getEntryTime() const { return entryTime; }
    long long getExitTime() const { return exitTime; }
    TicketStatus getStatus() const { return status; }

private:
    Ticket(Vehicle* vehicle, ParkingSpot* spot, long long entryTime)
        : id("T-" + std::to_string(nextId++)), vehicle(vehicle), spot(spot),
          entryTime(entryTime), exitTime(0), status(TicketStatus::ACTIVE) {}

    static int nextId;
    std::string id;
    Vehicle* vehicle;
    ParkingSpot* spot;
    long long entryTime;
    long long exitTime;
    TicketStatus status;
};
int Ticket::nextId = 1;

// ---------- SpotAllocator (interface) + strategies ----------
class SpotAllocator {
public:
    virtual ~SpotAllocator() = default;
    virtual ParkingSpot* allocate(Vehicle* vehicle) = 0;
};

// Picks the first free compatible spot, scanning floors in order.
class FirstAvailableAllocator : public SpotAllocator {
public:
    explicit FirstAvailableAllocator(std::vector<Floor*> floors) : floors(std::move(floors)) {}
    ParkingSpot* allocate(Vehicle* vehicle) override {
        for (auto* f : floors) {
            ParkingSpot* spot = f->findAvailableSpot(vehicle->getSize());
            if (spot) return spot;
        }
        return nullptr;
    }
private:
    std::vector<Floor*> floors;
};

// Picks the compatible spot whose size is the closest fit (least wasted space).
class NearestSpotAllocator : public SpotAllocator {
public:
    explicit NearestSpotAllocator(std::vector<Floor*> floors) : floors(std::move(floors)) {}
    ParkingSpot* allocate(Vehicle* vehicle) override {
        ParkingSpot* best = nullptr;
        for (auto* f : floors) {
            for (auto& s : f->getSpots()) {
                if (!s->canFit(vehicle->getSize())) continue;
                if (!best || static_cast<int>(s->getSize()) < static_cast<int>(best->getSize())) best = s.get();
            }
        }
        return best;
    }
private:
    std::vector<Floor*> floors;
};

// ---------- FeeStrategy (interface) + strategies ----------
class FeeStrategy {
public:
    virtual ~FeeStrategy() = default;
    virtual double calculate(const Ticket& closedTicket) const = 0;
};

class HourlyFeeStrategy : public FeeStrategy {
public:
    explicit HourlyFeeStrategy(double ratePerHour) : ratePerHour(ratePerHour) {}
    double calculate(const Ticket& t) const override {
        long long durationMs = t.getExitTime() - t.getEntryTime();
        double hours = std::max(1.0, std::ceil(durationMs / 3600000.0));
        return hours * ratePerHour;
    }
private:
    double ratePerHour;
};

// Applies a surcharge multiplier if entry happened during peak hours (9-11, 17-19).
class PeakHourFeeStrategy : public FeeStrategy {
public:
    PeakHourFeeStrategy(double ratePerHour, double peakMultiplier)
        : ratePerHour(ratePerHour), peakMultiplier(peakMultiplier) {}
    double calculate(const Ticket& t) const override {
        long long durationMs = t.getExitTime() - t.getEntryTime();
        double hours = std::max(1.0, std::ceil(durationMs / 3600000.0));
        int entryHour = static_cast<int>((t.getEntryTime() / 3600000) % 24);
        bool peak = (entryHour >= 9 && entryHour < 11) || (entryHour >= 17 && entryHour < 19);
        return hours * ratePerHour * (peak ? peakMultiplier : 1.0);
    }
private:
    double ratePerHour;
    double peakMultiplier;
};

// ---------- Exceptions ----------
class NoAvailableSpotException : public std::runtime_error {
public:
    explicit NoAvailableSpotException(const std::string& msg) : std::runtime_error(msg) {}
};
class InvalidTicketException : public std::runtime_error {
public:
    explicit InvalidTicketException(const std::string& msg) : std::runtime_error(msg) {}
};

// ---------- ParkingLot (facade) ----------
class ParkingLot {
public:
    ParkingLot(std::vector<Floor*> floors, std::unique_ptr<SpotAllocator> allocator,
               std::unique_ptr<FeeStrategy> feeStrategy)
        : floors(std::move(floors)), allocator(std::move(allocator)), feeStrategy(std::move(feeStrategy)) {}

    std::unique_ptr<Ticket> parkVehicle(Vehicle* vehicle) {
        // Single lock guarding "decide spot + occupy spot", which spans two separate
        // objects (allocator, spot) and cannot be made atomic by either object alone.
        std::lock_guard<std::mutex> guard(lock);
        ParkingSpot* spot = allocator->allocate(vehicle);
        if (!spot) throw NoAvailableSpotException("No available spot for this vehicle size");
        spot->occupy(vehicle);
        return Ticket::create(vehicle, spot, nowMs());
    }

    double unparkVehicle(Ticket* ticket) {
        std::lock_guard<std::mutex> guard(lock);
        if (ticket->getStatus() != TicketStatus::ACTIVE) throw InvalidTicketException("Ticket not active: " + ticket->getId());
        ticket->close(nowMs());
        double fee = feeStrategy->calculate(*ticket);
        ticket->getSpot()->vacate();
        return fee;
    }

private:
    static long long nowMs() {
        return std::chrono::duration_cast<std::chrono::milliseconds>(
                   std::chrono::system_clock::now().time_since_epoch())
            .count();
    }

    std::vector<Floor*> floors;
    std::unique_ptr<SpotAllocator> allocator;
    std::unique_ptr<FeeStrategy> feeStrategy;
    std::mutex lock;
};

// ---------- Demo ----------
int main() {
    std::vector<std::unique_ptr<ParkingSpot>> f1Spots;
    f1Spots.push_back(std::make_unique<ParkingSpot>("F1-M1", VehicleSize::MOTORCYCLE));
    f1Spots.push_back(std::make_unique<ParkingSpot>("F1-C1", VehicleSize::COMPACT));
    Floor floor1(1, std::move(f1Spots));
    std::vector<Floor*> floors = {&floor1};

    auto allocator = std::make_unique<NearestSpotAllocator>(floors);
    auto feeStrategy = std::make_unique<HourlyFeeStrategy>(10.0);
    ParkingLot lot(floors, std::move(allocator), std::move(feeStrategy));

    Car car("KA-01-1234");
    auto t1 = lot.parkVehicle(&car);
    std::cout << "Parked car, ticket=" << t1->getId() << " spot=" << t1->getSpot()->getId() << "\n";

    Motorcycle bike("KA-01-5678");
    auto t2 = lot.parkVehicle(&bike);
    std::cout << "Parked bike, ticket=" << t2->getId() << " spot=" << t2->getSpot()->getId() << "\n";

    try {
        Bus bus("KA-01-9999");
        lot.parkVehicle(&bus); // no LARGE spot exists -> should fail
    } catch (const NoAvailableSpotException& e) {
        std::cout << "Expected failure parking bus: " << e.what() << "\n";
    }

    double fee = lot.unparkVehicle(t1.get());
    std::cout << "Unparked car, fee=" << fee << "\n";
    return 0;
}

// Parking Lot - full LLD implementation (single-file demo).
// Difficulty badge includes "Concurrency". Node's event loop is single-threaded, so true
// data races can't happen here, but we still model the critical section explicitly with a
// tiny async mutex so the *design* correctly reflects "allocate+occupy must be atomic" -
// this matters if this class were ever ported to a worker-thread / multi-process context.

// ---------- Vehicle hierarchy ----------
const VehicleSize = { MOTORCYCLE: 0, COMPACT: 1, LARGE: 2 };

class Vehicle {
  constructor(licensePlate) {
    if (new.target === Vehicle) throw new Error("Vehicle is abstract");
    this.licensePlate = licensePlate;
  }
  getSize() {
    throw new Error("getSize() must be implemented by subclass");
  }
}

class Motorcycle extends Vehicle {
  getSize() { return VehicleSize.MOTORCYCLE; }
}

class Car extends Vehicle {
  getSize() { return VehicleSize.COMPACT; }
}

class Bus extends Vehicle {
  getSize() { return VehicleSize.LARGE; }
}

// ---------- ParkingSpot ----------
class ParkingSpot {
  constructor(id, size) {
    this.id = id;
    this.size = size;
    this.occupied = false;
    this.currentVehicle = null;
  }

  // A larger spot can host a smaller vehicle; VehicleSize values are ordered
  // smallest-to-largest so a simple numeric compare works.
  canFit(vehicleSize) {
    return !this.occupied && this.size >= vehicleSize;
  }

  occupy(vehicle) {
    if (this.occupied) throw new Error(`Spot ${this.id} already occupied`);
    this.occupied = true;
    this.currentVehicle = vehicle;
  }

  vacate() {
    this.occupied = false;
    this.currentVehicle = null;
  }
}

// ---------- Floor ----------
class Floor {
  constructor(floorNumber, spots) {
    this.floorNumber = floorNumber;
    this.spots = spots;
  }

  // First compatible free spot on this floor, or null if none.
  findAvailableSpot(size) {
    for (const s of this.spots) {
      if (s.canFit(size)) return s;
    }
    return null;
  }
}

// ---------- Ticket ----------
const TicketStatus = { ACTIVE: "ACTIVE", CLOSED: "CLOSED" };

let __ticketSeq = 1;
class Ticket {
  constructor(vehicle, spot, entryTime) {
    this.id = `T-${__ticketSeq++}`;
    this.vehicle = vehicle;
    this.spot = spot;
    this.entryTime = entryTime;
    this.exitTime = null;
    this.status = TicketStatus.ACTIVE;
  }

  static create(vehicle, spot, entryTime) {
    return new Ticket(vehicle, spot, entryTime);
  }

  close(exitTime) {
    this.exitTime = exitTime;
    this.status = TicketStatus.CLOSED;
  }
}

// ---------- SpotAllocator (interface) + strategies ----------
class SpotAllocator {
  allocate(_vehicle) {
    throw new Error("allocate() must be implemented");
  }
}

// Picks the first free compatible spot, scanning floors in order.
class FirstAvailableAllocator extends SpotAllocator {
  constructor(floors) {
    super();
    this.floors = floors;
  }
  allocate(vehicle) {
    for (const f of this.floors) {
      const spot = f.findAvailableSpot(vehicle.getSize());
      if (spot) return spot;
    }
    return null;
  }
}

// Picks the compatible spot whose size is the closest fit (least wasted space).
class NearestSpotAllocator extends SpotAllocator {
  constructor(floors) {
    super();
    this.floors = floors;
  }
  allocate(vehicle) {
    let best = null;
    for (const f of this.floors) {
      for (const s of f.spots) {
        if (!s.canFit(vehicle.getSize())) continue;
        if (!best || s.size < best.size) best = s;
      }
    }
    return best;
  }
}

// ---------- FeeStrategy (interface) + strategies ----------
class FeeStrategy {
  calculate(_closedTicket) {
    throw new Error("calculate() must be implemented");
  }
}

class HourlyFeeStrategy extends FeeStrategy {
  constructor(ratePerHour) {
    super();
    this.ratePerHour = ratePerHour;
  }
  calculate(t) {
    const durationMs = t.exitTime - t.entryTime;
    const hours = Math.max(1, Math.ceil(durationMs / 3600000));
    return hours * this.ratePerHour;
  }
}

// Applies a surcharge multiplier if entry happened during peak hours (9-11, 17-19).
class PeakHourFeeStrategy extends FeeStrategy {
  constructor(ratePerHour, peakMultiplier) {
    super();
    this.ratePerHour = ratePerHour;
    this.peakMultiplier = peakMultiplier;
  }
  calculate(t) {
    const durationMs = t.exitTime - t.entryTime;
    const hours = Math.max(1, Math.ceil(durationMs / 3600000));
    const entryHour = Math.floor(t.entryTime / 3600000) % 24;
    const peak = (entryHour >= 9 && entryHour < 11) || (entryHour >= 17 && entryHour < 19);
    return hours * this.ratePerHour * (peak ? this.peakMultiplier : 1);
  }
}

// ---------- Errors ----------
class NoAvailableSpotException extends Error {}
class InvalidTicketException extends Error {}

// ---------- Tiny async mutex (see file header for why) ----------
class Mutex {
  constructor() { this._locked = false; this._waiters = []; }
  async acquire() {
    if (!this._locked) { this._locked = true; return; }
    await new Promise((resolve) => this._waiters.push(resolve));
    this._locked = true;
  }
  release() {
    this._locked = false;
    const next = this._waiters.shift();
    if (next) next();
  }
}

// ---------- ParkingLot (facade) ----------
class ParkingLot {
  constructor(floors, allocator, feeStrategy) {
    this.floors = floors;
    this.allocator = allocator; // injected interface, not a concrete class
    this.feeStrategy = feeStrategy; // injected interface, not a concrete class
    this.lock = new Mutex();
  }

  async parkVehicle(vehicle) {
    await this.lock.acquire();
    try {
      const spot = this.allocator.allocate(vehicle);
      if (!spot) throw new NoAvailableSpotException(`No available spot for vehicle size ${vehicle.getSize()}`);
      spot.occupy(vehicle);
      return Ticket.create(vehicle, spot, Date.now());
    } finally {
      this.lock.release();
    }
  }

  async unparkVehicle(ticket) {
    await this.lock.acquire();
    try {
      if (ticket.status !== TicketStatus.ACTIVE) throw new InvalidTicketException(`Ticket not active: ${ticket.id}`);
      ticket.close(Date.now());
      const fee = this.feeStrategy.calculate(ticket);
      ticket.spot.vacate();
      return fee;
    } finally {
      this.lock.release();
    }
  }
}

// ---------- Demo ----------
async function main() {
  const f1Spots = [
    new ParkingSpot("F1-M1", VehicleSize.MOTORCYCLE),
    new ParkingSpot("F1-C1", VehicleSize.COMPACT),
  ];
  const floor1 = new Floor(1, f1Spots);
  const floors = [floor1];

  const allocator = new NearestSpotAllocator(floors);
  const feeStrategy = new HourlyFeeStrategy(10.0);
  const lot = new ParkingLot(floors, allocator, feeStrategy);

  const car = new Car("KA-01-1234");
  const t1 = await lot.parkVehicle(car);
  console.log(`Parked car, ticket=${t1.id} spot=${t1.spot.id}`);

  const bike = new Motorcycle("KA-01-5678");
  const t2 = await lot.parkVehicle(bike);
  console.log(`Parked bike, ticket=${t2.id} spot=${t2.spot.id}`);

  try {
    const bus = new Bus("KA-01-9999");
    await lot.parkVehicle(bus); // no LARGE spot exists -> should fail
  } catch (e) {
    console.log(`Expected failure parking bus: ${e.message}`);
  }

  const fee = await lot.unparkVehicle(t1);
  console.log(`Unparked car, fee=${fee}`);
}

if (require.main === module) {
  main();
}

module.exports = {
  VehicleSize, Vehicle, Motorcycle, Car, Bus, ParkingSpot, Floor, Ticket, TicketStatus,
  SpotAllocator, FirstAvailableAllocator, NearestSpotAllocator,
  FeeStrategy, HourlyFeeStrategy, PeakHourFeeStrategy,
  NoAvailableSpotException, InvalidTicketException, ParkingLot,
};

// Parking Lot - full LLD implementation (single-file demo).
// Difficulty badge includes "Concurrency". JS/TS is single-threaded, so true data races
// can't happen, but the critical section is still modeled explicitly with a tiny async
// mutex so the *design* reflects "allocate+occupy must be atomic" faithfully.

// ---------- Vehicle hierarchy ----------
enum VehicleSize {
  MOTORCYCLE = 0,
  COMPACT = 1,
  LARGE = 2,
}

abstract class Vehicle {
  constructor(protected readonly licensePlate: string) {}
  abstract getSize(): VehicleSize;
  getLicensePlate(): string { return this.licensePlate; }
}

class Motorcycle extends Vehicle {
  getSize(): VehicleSize { return VehicleSize.MOTORCYCLE; }
}

class Car extends Vehicle {
  getSize(): VehicleSize { return VehicleSize.COMPACT; }
}

class Bus extends Vehicle {
  getSize(): VehicleSize { return VehicleSize.LARGE; }
}

// ---------- ParkingSpot ----------
class ParkingSpot {
  private occupied = false;
  private currentVehicle: Vehicle | null = null;

  constructor(private readonly id: string, private readonly size: VehicleSize) {}

  getId(): string { return this.id; }
  getSize(): VehicleSize { return this.size; }
  isOccupied(): boolean { return this.occupied; }

  // A larger spot can host a smaller vehicle; VehicleSize is ordered smallest-to-largest.
  canFit(vehicleSize: VehicleSize): boolean {
    return !this.occupied && this.size >= vehicleSize;
  }

  occupy(vehicle: Vehicle): void {
    if (this.occupied) throw new Error(`Spot ${this.id} already occupied`);
    this.occupied = true;
    this.currentVehicle = vehicle;
  }

  vacate(): void {
    this.occupied = false;
    this.currentVehicle = null;
  }
}

// ---------- Floor ----------
class Floor {
  constructor(private readonly floorNumber: number, private readonly spots: ParkingSpot[]) {}

  getFloorNumber(): number { return this.floorNumber; }
  getSpots(): ParkingSpot[] { return this.spots; }

  // First compatible free spot on this floor, or null if none.
  findAvailableSpot(size: VehicleSize): ParkingSpot | null {
    for (const s of this.spots) {
      if (s.canFit(size)) return s;
    }
    return null;
  }
}

// ---------- Ticket ----------
enum TicketStatus { ACTIVE = "ACTIVE", CLOSED = "CLOSED" }

let ticketSeq = 1;
class Ticket {
  readonly id: string;
  exitTime: number | null = null;
  status: TicketStatus = TicketStatus.ACTIVE;

  private constructor(
    readonly vehicle: Vehicle,
    readonly spot: ParkingSpot,
    readonly entryTime: number
  ) {
    this.id = `T-${ticketSeq++}`;
  }

  static create(vehicle: Vehicle, spot: ParkingSpot, entryTime: number): Ticket {
    return new Ticket(vehicle, spot, entryTime);
  }

  close(exitTime: number): void {
    this.exitTime = exitTime;
    this.status = TicketStatus.CLOSED;
  }
}

// ---------- SpotAllocator (interface) + strategies ----------
interface SpotAllocator {
  allocate(vehicle: Vehicle): ParkingSpot | null;
}

// Picks the first free compatible spot, scanning floors in order.
class FirstAvailableAllocator implements SpotAllocator {
  constructor(private readonly floors: Floor[]) {}
  allocate(vehicle: Vehicle): ParkingSpot | null {
    for (const f of this.floors) {
      const spot = f.findAvailableSpot(vehicle.getSize());
      if (spot) return spot;
    }
    return null;
  }
}

// Picks the compatible spot whose size is the closest fit (least wasted space).
class NearestSpotAllocator implements SpotAllocator {
  constructor(private readonly floors: Floor[]) {}
  allocate(vehicle: Vehicle): ParkingSpot | null {
    let best: ParkingSpot | null = null;
    for (const f of this.floors) {
      for (const s of f.getSpots()) {
        if (!s.canFit(vehicle.getSize())) continue;
        if (!best || s.getSize() < best.getSize()) best = s;
      }
    }
    return best;
  }
}

// ---------- FeeStrategy (interface) + strategies ----------
interface FeeStrategy {
  calculate(closedTicket: Ticket): number;
}

class HourlyFeeStrategy implements FeeStrategy {
  constructor(private readonly ratePerHour: number) {}
  calculate(t: Ticket): number {
    const durationMs = (t.exitTime ?? 0) - t.entryTime;
    const hours = Math.max(1, Math.ceil(durationMs / 3600000));
    return hours * this.ratePerHour;
  }
}

// Applies a surcharge multiplier if entry happened during peak hours (9-11, 17-19).
class PeakHourFeeStrategy implements FeeStrategy {
  constructor(private readonly ratePerHour: number, private readonly peakMultiplier: number) {}
  calculate(t: Ticket): number {
    const durationMs = (t.exitTime ?? 0) - t.entryTime;
    const hours = Math.max(1, Math.ceil(durationMs / 3600000));
    const entryHour = Math.floor(t.entryTime / 3600000) % 24;
    const peak = (entryHour >= 9 && entryHour < 11) || (entryHour >= 17 && entryHour < 19);
    return hours * this.ratePerHour * (peak ? this.peakMultiplier : 1);
  }
}

// ---------- Errors ----------
class NoAvailableSpotException extends Error {}
class InvalidTicketException extends Error {}

// ---------- Tiny async mutex (see file header for why) ----------
class Mutex {
  private locked = false;
  private waiters: Array<() => void> = [];

  async acquire(): Promise<void> {
    if (!this.locked) { this.locked = true; return; }
    await new Promise<void>((resolve) => this.waiters.push(resolve));
    this.locked = true;
  }

  release(): void {
    this.locked = false;
    const next = this.waiters.shift();
    if (next) next();
  }
}

// ---------- ParkingLot (facade) ----------
class ParkingLot {
  private readonly lock = new Mutex();

  constructor(
    private readonly floors: Floor[],
    private readonly allocator: SpotAllocator,   // injected interface, not a concrete class
    private readonly feeStrategy: FeeStrategy     // injected interface, not a concrete class
  ) {}

  async parkVehicle(vehicle: Vehicle): Promise<Ticket> {
    await this.lock.acquire();
    try {
      const spot = this.allocator.allocate(vehicle);
      if (!spot) throw new NoAvailableSpotException(`No available spot for vehicle size ${vehicle.getSize()}`);
      spot.occupy(vehicle);
      return Ticket.create(vehicle, spot, Date.now());
    } finally {
      this.lock.release();
    }
  }

  async unparkVehicle(ticket: Ticket): Promise<number> {
    await this.lock.acquire();
    try {
      if (ticket.status !== TicketStatus.ACTIVE) throw new InvalidTicketException(`Ticket not active: ${ticket.id}`);
      ticket.close(Date.now());
      const fee = this.feeStrategy.calculate(ticket);
      ticket.spot.vacate();
      return fee;
    } finally {
      this.lock.release();
    }
  }
}

// ---------- Demo ----------
async function main(): Promise<void> {
  const f1Spots: ParkingSpot[] = [
    new ParkingSpot("F1-M1", VehicleSize.MOTORCYCLE),
    new ParkingSpot("F1-C1", VehicleSize.COMPACT),
  ];
  const floor1 = new Floor(1, f1Spots);
  const floors: Floor[] = [floor1];

  const allocator: SpotAllocator = new NearestSpotAllocator(floors);
  const feeStrategy: FeeStrategy = new HourlyFeeStrategy(10.0);
  const lot = new ParkingLot(floors, allocator, feeStrategy);

  const car = new Car("KA-01-1234");
  const t1 = await lot.parkVehicle(car);
  console.log(`Parked car, ticket=${t1.id} spot=${t1.spot.getId()}`);

  const bike = new Motorcycle("KA-01-5678");
  const t2 = await lot.parkVehicle(bike);
  console.log(`Parked bike, ticket=${t2.id} spot=${t2.spot.getId()}`);

  try {
    const bus = new Bus("KA-01-9999");
    await lot.parkVehicle(bus); // no LARGE spot exists -> should fail
  } catch (e) {
    console.log(`Expected failure parking bus: ${(e as Error).message}`);
  }

  const fee = await lot.unparkVehicle(t1);
  console.log(`Unparked car, fee=${fee}`);
}

main();

export {
  VehicleSize, Vehicle, Motorcycle, Car, Bus, ParkingSpot, Floor, Ticket, TicketStatus,
  SpotAllocator, FirstAvailableAllocator, NearestSpotAllocator,
  FeeStrategy, HourlyFeeStrategy, PeakHourFeeStrategy,
  NoAvailableSpotException, InvalidTicketException, ParkingLot,
};