Restaurant Booking System

import threading
from datetime import date, time, datetime
from enum import Enum
from dataclasses import dataclass, field
from typing import List, Optional, Protocol


# --- Enums ---

class TableType(Enum):
    INDOOR = "INDOOR"
    OUTDOOR = "OUTDOOR"
    VIP = "VIP"


class BookingStatus(Enum):
    CONFIRMED = "CONFIRMED"
    SEATED = "SEATED"
    COMPLETED = "COMPLETED"
    CANCELLED = "CANCELLED"


# --- TimeSlot ---

@dataclass
class TimeSlot:
    date: date
    start_time: time
    end_time: time

    def overlaps_with(self, other: "TimeSlot") -> bool:
        if self.date != other.date:
            return False
        return self.start_time < other.end_time and other.start_time < self.end_time

    def __hash__(self):
        return hash((self.date, self.start_time, self.end_time))

    def __eq__(self, other):
        if not isinstance(other, TimeSlot):
            return False
        return (self.date == other.date and self.start_time == other.start_time
                and self.end_time == other.end_time)

    def __str__(self):
        return f"{self.date} {self.start_time}-{self.end_time}"

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <list>
#include <algorithm>
#include <mutex>
#include <memory>
#include <stdexcept>
#include <sstream>
#include <chrono>

// --- Enums ---

enum class TableType { INDOOR, OUTDOOR, VIP };
enum class BookingStatus { CONFIRMED, SEATED, COMPLETED, CANCELLED };

std::string tableTypeStr(TableType t) {
    switch (t) {
        case TableType::INDOOR: return "INDOOR";
        case TableType::OUTDOOR: return "OUTDOOR";
        case TableType::VIP: return "VIP";
    }
    return "";
}

std::string bookingStatusStr(BookingStatus s) {
    switch (s) {
        case BookingStatus::CONFIRMED: return "CONFIRMED";
        case BookingStatus::SEATED: return "SEATED";
        case BookingStatus::COMPLETED: return "COMPLETED";
        case BookingStatus::CANCELLED: return "CANCELLED";
    }
    return "";
}

// --- TimeSlot ---

struct TimeSlot {
    int year, month, day;
    int startHour, startMin;
    int endHour, endMin;

    bool overlapsWith(const TimeSlot& other) const {
        if (year != other.year || month != other.month || day != other.day) return false;
        int thisStart = startHour * 60 + startMin;
        int thisEnd = endHour * 60 + endMin;
        int otherStart = other.startHour * 60 + other.startMin;
        int otherEnd = other.endHour * 60 + other.endMin;
        return thisStart < otherEnd && otherStart < thisEnd;
    }

    bool operator==(const TimeSlot& other) const {
        return year == other.year && month == other.month && day == other.day
            && startHour == other.startHour && startMin == other.startMin
            && endHour == other.endHour && endMin == other.endMin;
    }

    bool operator<(const TimeSlot& other) const {
        if (year != other.year) return year < other.year;
        if (month != other.month) return month < other.month;
        if (day != other.day) return day < other.day;
        if (startHour != other.startHour) return startHour < other.startHour;
        return startMin < other.startMin;
    }

    std::string toString() const {
        std::ostringstream oss;
        oss << year << "-" << month << "-" << day << " "
            << startHour << ":" << (startMin < 10 ? "0" : "") << startMin
            << "-" << endHour << ":" << (endMin < 10 ? "0" : "") << endMin;
        return oss.str();
    }
};

// --- Restaurant Booking System (JavaScript) ---

// --- Enums ---

const TableType = Object.freeze({ INDOOR: "INDOOR", OUTDOOR: "OUTDOOR", VIP: "VIP" });
const BookingStatus = Object.freeze({
    CONFIRMED: "CONFIRMED", SEATED: "SEATED", COMPLETED: "COMPLETED", CANCELLED: "CANCELLED"
});

// --- TimeSlot ---

class TimeSlot {
    constructor(date, startTime, endTime) {
        this.date = date;         // "YYYY-MM-DD"
        this.startTime = startTime; // "HH:MM"
        this.endTime = endTime;     // "HH:MM"
    }

    overlapsWith(other) {
        if (this.date !== other.date) return false;
        return this.startTime < other.endTime && other.startTime < this.endTime;
    }

    key() { return `${this.date}_${this.startTime}_${this.endTime}`; }

    toString() { return `${this.date} ${this.startTime}-${this.endTime}`; }
}

@dataclass
class Table:
    id: str
    capacity: int
    table_type: TableType

    def __str__(self):
        return f"Table-{self.id}({self.table_type.value}, seats:{self.capacity})"


@dataclass
class Booking:
    id: str
    customer_name: str
    party_size: int
    table: Table
    time_slot: TimeSlot
    status: BookingStatus = BookingStatus.CONFIRMED

    def seat(self):
        if self.status != BookingStatus.CONFIRMED:
            raise ValueError(f"Can only seat from CONFIRMED. Current: {self.status.value}")
        self.status = BookingStatus.SEATED

    def complete(self):
        if self.status != BookingStatus.SEATED:
            raise ValueError(f"Can only complete from SEATED. Current: {self.status.value}")
        self.status = BookingStatus.COMPLETED

    def cancel(self):
        if self.status != BookingStatus.CONFIRMED:
            raise ValueError(f"Can only cancel from CONFIRMED. Current: {self.status.value}")
        self.status = BookingStatus.CANCELLED

    def __str__(self):
        return (f"Booking[{self.id}] {self.customer_name} party:{self.party_size} "
                f"{self.table} {self.time_slot} status:{self.status.value}")

struct Table {
    std::string id;
    int capacity;
    TableType tableType;

    std::string toString() const {
        return "Table-" + id + "(" + tableTypeStr(tableType) + ", seats:" + std::to_string(capacity) + ")";
    }
};

struct Booking {
    std::string id;
    std::string customerName;
    int partySize;
    std::shared_ptr<Table> table;
    TimeSlot timeSlot;
    BookingStatus status = BookingStatus::CONFIRMED;

    void seat() {
        if (status != BookingStatus::CONFIRMED)
            throw std::runtime_error("Can only seat from CONFIRMED. Current: " + bookingStatusStr(status));
        status = BookingStatus::SEATED;
    }

    void complete() {
        if (status != BookingStatus::SEATED)
            throw std::runtime_error("Can only complete from SEATED. Current: " + bookingStatusStr(status));
        status = BookingStatus::COMPLETED;
    }

    void cancel() {
        if (status != BookingStatus::CONFIRMED)
            throw std::runtime_error("Can only cancel from CONFIRMED. Current: " + bookingStatusStr(status));
        status = BookingStatus::CANCELLED;
    }

    std::string toString() const {
        return "Booking[" + id + "] " + customerName + " party:" + std::to_string(partySize)
               + " " + table->toString() + " " + timeSlot.toString() + " status:" + bookingStatusStr(status);
    }
};

class Table {
    constructor(id, capacity, tableType) {
        this.id = id;
        this.capacity = capacity;
        this.tableType = tableType;
    }

    toString() { return `Table-${this.id}(${this.tableType}, seats:${this.capacity})`; }
}

class Booking {
    constructor(id, customerName, partySize, table, timeSlot) {
        this.id = id;
        this.customerName = customerName;
        this.partySize = partySize;
        this.table = table;
        this.timeSlot = timeSlot;
        this.status = BookingStatus.CONFIRMED;
    }

    seat() {
        if (this.status !== BookingStatus.CONFIRMED)
            throw new Error(`Can only seat from CONFIRMED. Current: ${this.status}`);
        this.status = BookingStatus.SEATED;
    }

    complete() {
        if (this.status !== BookingStatus.SEATED)
            throw new Error(`Can only complete from SEATED. Current: ${this.status}`);
        this.status = BookingStatus.COMPLETED;
    }

    cancel() {
        if (this.status !== BookingStatus.CONFIRMED)
            throw new Error(`Can only cancel from CONFIRMED. Current: ${this.status}`);
        this.status = BookingStatus.CANCELLED;
    }

    toString() {
        return `Booking[${this.id}] ${this.customerName} party:${this.partySize} ` +
               `${this.table.toString()} ${this.timeSlot.toString()} status:${this.status}`;
    }
}

@dataclass
class WaitlistEntry:
    customer_name: str
    party_size: int
    time_slot: TimeSlot
    added_at: datetime = field(default_factory=datetime.now)

    def __str__(self):
        return f"Waitlist[{self.customer_name} party:{self.party_size} slot:{self.time_slot}]"

struct WaitlistEntry {
    std::string customerName;
    int partySize;
    TimeSlot timeSlot;

    std::string toString() const {
        return "Waitlist[" + customerName + " party:" + std::to_string(partySize)
               + " slot:" + timeSlot.toString() + "]";
    }
};

class WaitlistEntry {
    constructor(customerName, partySize, timeSlot) {
        this.customerName = customerName;
        this.partySize = partySize;
        this.timeSlot = timeSlot;
        this.addedAt = new Date();
    }

    toString() {
        return `Waitlist[${this.customerName} party:${this.partySize} slot:${this.timeSlot.toString()}]`;
    }
}

# --- Strategy Pattern ---

class TableAssignmentStrategy(Protocol):
    def assign_table(self, available_tables: List[Table], party_size: int) -> Optional[Table]:
        ...


class FirstFitStrategy:
    def assign_table(self, available_tables: List[Table], party_size: int) -> Optional[Table]:
        for table in available_tables:
            if table.capacity >= party_size:
                return table
        return None


class BestFitStrategy:
    def assign_table(self, available_tables: List[Table], party_size: int) -> Optional[Table]:
        fitting = [t for t in available_tables if t.capacity >= party_size]
        if not fitting:
            return None
        return min(fitting, key=lambda t: t.capacity)

// --- Strategy Pattern ---

class TableAssignmentStrategy {
public:
    virtual ~TableAssignmentStrategy() = default;
    virtual std::shared_ptr<Table> assignTable(
        const std::vector<std::shared_ptr<Table>>& available, int partySize) = 0;
};

class FirstFitStrategy : public TableAssignmentStrategy {
public:
    std::shared_ptr<Table> assignTable(
        const std::vector<std::shared_ptr<Table>>& available, int partySize) override {
        for (auto& t : available) {
            if (t->capacity >= partySize) return t;
        }
        return nullptr;
    }
};

class BestFitStrategy : public TableAssignmentStrategy {
public:
    std::shared_ptr<Table> assignTable(
        const std::vector<std::shared_ptr<Table>>& available, int partySize) override {
        std::shared_ptr<Table> best = nullptr;
        for (auto& t : available) {
            if (t->capacity >= partySize) {
                if (!best || t->capacity < best->capacity) {
                    best = t;
                }
            }
        }
        return best;
    }
};

// --- Strategy Pattern ---

class FirstFitStrategy {
    assignTable(availableTables, partySize) {
        return availableTables.find(t => t.capacity >= partySize) || null;
    }
}

class BestFitStrategy {
    assignTable(availableTables, partySize) {
        const fitting = availableTables
            .filter(t => t.capacity >= partySize)
            .sort((a, b) => a.capacity - b.capacity);
        return fitting.length > 0 ? fitting[0] : null;
    }
}

# --- Repositories ---

class InMemoryTableRepository:
    def __init__(self):
        self._tables: dict[str, Table] = {}

    def save(self, table: Table):
        self._tables[table.id] = table

    def find_by_id(self, table_id: str) -> Optional[Table]:
        return self._tables.get(table_id)

    def find_all(self) -> List[Table]:
        return list(self._tables.values())


class InMemoryBookingRepository:
    def __init__(self):
        self._bookings: List[Booking] = []

    def save(self, booking: Booking):
        self._bookings.append(booking)

    def find_by_id(self, booking_id: str) -> Optional[Booking]:
        for b in self._bookings:
            if b.id == booking_id:
                return b
        return None

    def find_by_table_and_overlapping_slot(self, table_id: str, slot: TimeSlot) -> List[Booking]:
        return [
            b for b in self._bookings
            if b.table.id == table_id
            and b.status in (BookingStatus.CONFIRMED, BookingStatus.SEATED)
            and b.time_slot.overlaps_with(slot)
        ]


class InMemoryWaitlistRepository:
    def __init__(self):
        self._waitlist: dict[TimeSlot, list[WaitlistEntry]] = {}

    def add(self, entry: WaitlistEntry):
        self._waitlist.setdefault(entry.time_slot, []).append(entry)

    def get_by_slot(self, slot: TimeSlot) -> List[WaitlistEntry]:
        return self._waitlist.get(slot, [])

    def remove_first(self, slot: TimeSlot) -> Optional[WaitlistEntry]:
        entries = self._waitlist.get(slot, [])
        if not entries:
            return None
        return entries.pop(0)

// Note: In C++, the BookingService class below acts as its own repository
// using internal vectors and maps. No separate repository classes needed
// for this in-memory implementation.

// Note: In JavaScript, the BookingService class below acts as its own repository
// using internal arrays and Maps. No separate repository classes needed
// for this in-memory implementation.

# --- Booking Result ---

@dataclass
class BookingResult:
    booking: Optional[Booking] = None
    waitlisted: bool = False
    waitlist_entry: Optional[WaitlistEntry] = None

    def __str__(self):
        if self.waitlisted:
            return f"WAITLISTED: {self.waitlist_entry}"
        return f"CONFIRMED: {self.booking}"


# --- Booking Service ---

class BookingService:
    def __init__(self, strategy: TableAssignmentStrategy):
        self._table_repo = InMemoryTableRepository()
        self._booking_repo = InMemoryBookingRepository()
        self._waitlist_repo = InMemoryWaitlistRepository()
        self._strategy = strategy
        self._lock = threading.Lock()
        self._booking_counter = 0
        self._table_counter = 0

    def set_strategy(self, strategy: TableAssignmentStrategy):
        self._strategy = strategy

    def add_table(self, capacity: int, table_type: TableType) -> Table:
        self._table_counter += 1
        table = Table(f"T{self._table_counter}", capacity, table_type)
        self._table_repo.save(table)
        return table

    def get_available_tables(self, slot: TimeSlot, party_size: int) -> List[Table]:
        return [
            t for t in self._table_repo.find_all()
            if t.capacity >= party_size
            and not self._booking_repo.find_by_table_and_overlapping_slot(t.id, slot)
        ]

    def book_table(self, customer_name: str, party_size: int, slot: TimeSlot) -> BookingResult:
        with self._lock:
            available = self.get_available_tables(slot, party_size)
            assigned = self._strategy.assign_table(available, party_size)

            if assigned:
                self._booking_counter += 1
                booking = Booking(f"B{self._booking_counter}", customer_name,
                                  party_size, assigned, slot)
                self._booking_repo.save(booking)
                print(f"  >> Booked: {booking}")
                return BookingResult(booking=booking)
            else:
                entry = WaitlistEntry(customer_name, party_size, slot)
                self._waitlist_repo.add(entry)
                print(f"  >> Waitlisted: {entry}")
                return BookingResult(waitlisted=True, waitlist_entry=entry)

    def cancel_booking(self, booking_id: str):
        with self._lock:
            booking = self._booking_repo.find_by_id(booking_id)
            if not booking:
                raise ValueError(f"Booking not found: {booking_id}")
            booking.cancel()
            print(f"  >> Cancelled: {booking}")
            self._promote_from_waitlist(booking.time_slot)

    def _promote_from_waitlist(self, slot: TimeSlot):
        entry = self._waitlist_repo.remove_first(slot)
        if not entry:
            return

        available = self.get_available_tables(slot, entry.party_size)
        assigned = self._strategy.assign_table(available, entry.party_size)

        if assigned:
            self._booking_counter += 1
            booking = Booking(f"B{self._booking_counter}", entry.customer_name,
                              entry.party_size, assigned, slot)
            self._booking_repo.save(booking)
            print(f"  >> Promoted from waitlist: {booking}")
        else:
            self._waitlist_repo.add(entry)

    def seat_guests(self, booking_id: str):
        booking = self._booking_repo.find_by_id(booking_id)
        if not booking:
            raise ValueError(f"Booking not found: {booking_id}")
        booking.seat()
        print(f"  >> Seated: {booking}")

    def complete_booking(self, booking_id: str):
        booking = self._booking_repo.find_by_id(booking_id)
        if not booking:
            raise ValueError(f"Booking not found: {booking_id}")
        booking.complete()
        print(f"  >> Completed: {booking}")

    def get_waitlist(self, slot: TimeSlot) -> List[WaitlistEntry]:
        return self._waitlist_repo.get_by_slot(slot)

// --- Booking Result ---

struct BookingResult {
    std::shared_ptr<Booking> booking;
    bool waitlisted = false;
    std::shared_ptr<WaitlistEntry> waitlistEntry;

    std::string toString() const {
        if (waitlisted) return "WAITLISTED: " + waitlistEntry->toString();
        return "CONFIRMED: " + booking->toString();
    }
};

// --- Booking Service ---

class BookingService {
    std::vector<std::shared_ptr<Table>> tables;
    std::vector<std::shared_ptr<Booking>> bookings;
    std::map<TimeSlot, std::list<std::shared_ptr<WaitlistEntry>>> waitlist;
    std::shared_ptr<TableAssignmentStrategy> strategy;
    std::mutex mtx;
    int bookingCounter = 0;
    int tableCounter = 0;

public:
    BookingService(std::shared_ptr<TableAssignmentStrategy> strat) : strategy(strat) {}

    void setStrategy(std::shared_ptr<TableAssignmentStrategy> strat) {
        strategy = strat;
    }

    std::shared_ptr<Table> addTable(int capacity, TableType type) {
        auto table = std::make_shared<Table>();
        table->id = "T" + std::to_string(++tableCounter);
        table->capacity = capacity;
        table->tableType = type;
        tables.push_back(table);
        return table;
    }

    std::vector<std::shared_ptr<Table>> getAvailableTables(const TimeSlot& slot, int partySize) {
        std::vector<std::shared_ptr<Table>> available;
        for (auto& t : tables) {
            if (t->capacity < partySize) continue;
            bool conflict = false;
            for (auto& b : bookings) {
                if (b->table->id == t->id
                    && (b->status == BookingStatus::CONFIRMED || b->status == BookingStatus::SEATED)
                    && b->timeSlot.overlapsWith(slot)) {
                    conflict = true;
                    break;
                }
            }
            if (!conflict) available.push_back(t);
        }
        return available;
    }

    BookingResult bookTable(const std::string& customerName, int partySize, const TimeSlot& slot) {
        std::lock_guard<std::mutex> lock(mtx);
        auto available = getAvailableTables(slot, partySize);
        auto assigned = strategy->assignTable(available, partySize);

        if (assigned) {
            auto booking = std::make_shared<Booking>();
            booking->id = "B" + std::to_string(++bookingCounter);
            booking->customerName = customerName;
            booking->partySize = partySize;
            booking->table = assigned;
            booking->timeSlot = slot;
            bookings.push_back(booking);
            std::cout << "  >> Booked: " << booking->toString() << std::endl;
            return {booking, false, nullptr};
        } else {
            auto entry = std::make_shared<WaitlistEntry>();
            entry->customerName = customerName;
            entry->partySize = partySize;
            entry->timeSlot = slot;
            waitlist[slot].push_back(entry);
            std::cout << "  >> Waitlisted: " << entry->toString() << std::endl;
            return {nullptr, true, entry};
        }
    }

    void cancelBooking(const std::string& bookingId) {
        std::lock_guard<std::mutex> lock(mtx);
        auto booking = findBooking(bookingId);
        if (!booking) throw std::runtime_error("Booking not found: " + bookingId);
        booking->cancel();
        std::cout << "  >> Cancelled: " << booking->toString() << std::endl;
        promoteFromWaitlist(booking->timeSlot);
    }

    void seatGuests(const std::string& bookingId) {
        auto booking = findBooking(bookingId);
        if (!booking) throw std::runtime_error("Booking not found: " + bookingId);
        booking->seat();
        std::cout << "  >> Seated: " << booking->toString() << std::endl;
    }

    void completeBooking(const std::string& bookingId) {
        auto booking = findBooking(bookingId);
        if (!booking) throw std::runtime_error("Booking not found: " + bookingId);
        booking->complete();
        std::cout << "  >> Completed: " << booking->toString() << std::endl;
    }

    std::list<std::shared_ptr<WaitlistEntry>> getWaitlist(const TimeSlot& slot) {
        return waitlist[slot];
    }

private:
    std::shared_ptr<Booking> findBooking(const std::string& id) {
        for (auto& b : bookings) {
            if (b->id == id) return b;
        }
        return nullptr;
    }

    void promoteFromWaitlist(const TimeSlot& slot) {
        auto& list = waitlist[slot];
        if (list.empty()) return;

        auto entry = list.front();
        list.pop_front();

        auto available = getAvailableTables(slot, entry->partySize);
        auto assigned = strategy->assignTable(available, entry->partySize);

        if (assigned) {
            auto booking = std::make_shared<Booking>();
            booking->id = "B" + std::to_string(++bookingCounter);
            booking->customerName = entry->customerName;
            booking->partySize = entry->partySize;
            booking->table = assigned;
            booking->timeSlot = slot;
            bookings.push_back(booking);
            std::cout << "  >> Promoted from waitlist: " << booking->toString() << std::endl;
        } else {
            list.push_back(entry);
        }
    }
};

// --- Async Lock (single-threaded safety for async contexts) ---

class AsyncLock {
    constructor() { this._queue = []; this._locked = false; }

    async acquire() {
        if (!this._locked) {
            this._locked = true;
            return;
        }
        return new Promise(resolve => this._queue.push(resolve));
    }

    release() {
        if (this._queue.length > 0) {
            const next = this._queue.shift();
            next();
        } else {
            this._locked = false;
        }
    }
}

// --- Booking Service ---

class BookingService {
    constructor(strategy) {
        this.tables = [];
        this.bookings = [];
        this.waitlist = new Map(); // key(TimeSlot) -> WaitlistEntry[]
        this.strategy = strategy;
        this.lock = new AsyncLock();
        this.bookingCounter = 0;
        this.tableCounter = 0;
    }

    setStrategy(strategy) { this.strategy = strategy; }

    addTable(capacity, tableType) {
        const table = new Table(`T${++this.tableCounter}`, capacity, tableType);
        this.tables.push(table);
        return table;
    }

    getAvailableTables(slot, partySize) {
        return this.tables.filter(t => {
            if (t.capacity < partySize) return false;
            const hasConflict = this.bookings.some(b =>
                b.table.id === t.id &&
                (b.status === BookingStatus.CONFIRMED || b.status === BookingStatus.SEATED) &&
                b.timeSlot.overlapsWith(slot)
            );
            return !hasConflict;
        });
    }

    async bookTable(customerName, partySize, slot) {
        await this.lock.acquire();
        try {
            const available = this.getAvailableTables(slot, partySize);
            const assigned = this.strategy.assignTable(available, partySize);

            if (assigned) {
                const booking = new Booking(
                    `B${++this.bookingCounter}`, customerName, partySize, assigned, slot
                );
                this.bookings.push(booking);
                console.log(`  >> Booked: ${booking.toString()}`);
                return { booking, waitlisted: false };
            } else {
                const entry = new WaitlistEntry(customerName, partySize, slot);
                const key = slot.key();
                if (!this.waitlist.has(key)) this.waitlist.set(key, []);
                this.waitlist.get(key).push(entry);
                console.log(`  >> Waitlisted: ${entry.toString()}`);
                return { booking: null, waitlisted: true, waitlistEntry: entry };
            }
        } finally {
            this.lock.release();
        }
    }

    async cancelBooking(bookingId) {
        await this.lock.acquire();
        try {
            const booking = this.bookings.find(b => b.id === bookingId);
            if (!booking) throw new Error(`Booking not found: ${bookingId}`);
            booking.cancel();
            console.log(`  >> Cancelled: ${booking.toString()}`);
            this._promoteFromWaitlist(booking.timeSlot);
        } finally {
            this.lock.release();
        }
    }

    _promoteFromWaitlist(slot) {
        const key = slot.key();
        const entries = this.waitlist.get(key);
        if (!entries || entries.length === 0) return;

        const entry = entries.shift();
        const available = this.getAvailableTables(slot, entry.partySize);
        const assigned = this.strategy.assignTable(available, entry.partySize);

        if (assigned) {
            const booking = new Booking(
                `B${++this.bookingCounter}`, entry.customerName, entry.partySize, assigned, slot
            );
            this.bookings.push(booking);
            console.log(`  >> Promoted from waitlist: ${booking.toString()}`);
        } else {
            entries.unshift(entry);
        }
    }

    seatGuests(bookingId) {
        const booking = this.bookings.find(b => b.id === bookingId);
        if (!booking) throw new Error(`Booking not found: ${bookingId}`);
        booking.seat();
        console.log(`  >> Seated: ${booking.toString()}`);
    }

    completeBooking(bookingId) {
        const booking = this.bookings.find(b => b.id === bookingId);
        if (!booking) throw new Error(`Booking not found: ${bookingId}`);
        booking.complete();
        console.log(`  >> Completed: ${booking.toString()}`);
    }

    getWaitlist(slot) {
        return this.waitlist.get(slot.key()) || [];
    }
}

def main():
    print("=== Restaurant Booking System Demo ===\n")

    # Create service with BestFit strategy
    service = BookingService(BestFitStrategy())

    # Add tables
    print("--- Adding Tables ---")
    t1 = service.add_table(2, TableType.INDOOR)
    t2 = service.add_table(4, TableType.INDOOR)
    t3 = service.add_table(6, TableType.OUTDOOR)
    t4 = service.add_table(8, TableType.VIP)
    print(f"Added: {t1}, {t2}, {t3}, {t4}")

    # Define time slots
    friday_dinner = TimeSlot(date(2025, 1, 10), time(19, 0), time(21, 0))
    friday_late = TimeSlot(date(2025, 1, 10), time(20, 0), time(22, 0))

    # Book tables - BestFit assigns smallest fitting table
    print("\n--- Booking with BestFit Strategy ---")
    r1 = service.book_table("Alice", 2, friday_dinner)
    r2 = service.book_table("Bob", 4, friday_dinner)
    r3 = service.book_table("Charlie", 5, friday_dinner)
    r4 = service.book_table("Diana", 7, friday_dinner)

    # This should go to waitlist (all tables booked for overlapping slot)
    print("\n--- Conflict Detection (overlapping slot) ---")
    r5 = service.book_table("Eve", 2, friday_late)

    # Show waitlist
    print("\n--- Waitlist for Friday Late ---")
    for entry in service.get_waitlist(friday_late):
        print(f"  {entry}")

    # Cancel Alice's booking - should auto-promote Eve
    print("\n--- Cancel Alice (auto-promotes waitlist) ---")
    service.cancel_booking(r1.booking.id)

    # Demonstrate state transitions
    print("\n--- State Transitions ---")
    service.seat_guests(r2.booking.id)
    service.complete_booking(r2.booking.id)

    # Switch to FirstFit strategy
    print("\n--- Switch to FirstFit Strategy ---")
    service.set_strategy(FirstFitStrategy())
    saturday_dinner = TimeSlot(date(2025, 1, 11), time(19, 0), time(21, 0))
    r6 = service.book_table("Frank", 2, saturday_dinner)

    # Show available tables
    print("\n--- Available tables for Saturday Dinner (party of 2) ---")
    for t in service.get_available_tables(saturday_dinner, 2):
        print(f"  {t}")

    print("\n=== Demo Complete ===")


if __name__ == "__main__":
    main()

int main() {
    std::cout << "=== Restaurant Booking System Demo ===\n" << std::endl;

    auto service = std::make_unique<BookingService>(std::make_shared<BestFitStrategy>());

    // Add tables
    std::cout << "--- Adding Tables ---" << std::endl;
    auto t1 = service->addTable(2, TableType::INDOOR);
    auto t2 = service->addTable(4, TableType::INDOOR);
    auto t3 = service->addTable(6, TableType::OUTDOOR);
    auto t4 = service->addTable(8, TableType::VIP);
    std::cout << "Added: " << t1->toString() << ", " << t2->toString()
              << ", " << t3->toString() << ", " << t4->toString() << std::endl;

    // Define time slots
    TimeSlot fridayDinner = {2025, 1, 10, 19, 0, 21, 0};
    TimeSlot fridayLate = {2025, 1, 10, 20, 0, 22, 0};

    // Book tables - BestFit assigns smallest fitting table
    std::cout << "\n--- Booking with BestFit Strategy ---" << std::endl;
    auto r1 = service->bookTable("Alice", 2, fridayDinner);
    auto r2 = service->bookTable("Bob", 4, fridayDinner);
    auto r3 = service->bookTable("Charlie", 5, fridayDinner);
    auto r4 = service->bookTable("Diana", 7, fridayDinner);

    // This should go to waitlist
    std::cout << "\n--- Conflict Detection (overlapping slot) ---" << std::endl;
    auto r5 = service->bookTable("Eve", 2, fridayLate);

    // Show waitlist
    std::cout << "\n--- Waitlist for Friday Late ---" << std::endl;
    for (auto& e : service->getWaitlist(fridayLate)) {
        std::cout << "  " << e->toString() << std::endl;
    }

    // Cancel Alice - should auto-promote Eve
    std::cout << "\n--- Cancel Alice (auto-promotes waitlist) ---" << std::endl;
    service->cancelBooking(r1.booking->id);

    // Demonstrate state transitions
    std::cout << "\n--- State Transitions ---" << std::endl;
    service->seatGuests(r2.booking->id);
    service->completeBooking(r2.booking->id);

    // Switch to FirstFit strategy
    std::cout << "\n--- Switch to FirstFit Strategy ---" << std::endl;
    service->setStrategy(std::make_shared<FirstFitStrategy>());
    TimeSlot saturdayDinner = {2025, 1, 11, 19, 0, 21, 0};
    auto r6 = service->bookTable("Frank", 2, saturdayDinner);

    // Show available tables
    std::cout << "\n--- Available tables for Saturday Dinner (party of 2) ---" << std::endl;
    for (auto& t : service->getAvailableTables(saturdayDinner, 2)) {
        std::cout << "  " << t->toString() << std::endl;
    }

    std::cout << "\n=== Demo Complete ===" << std::endl;
    return 0;
}

async function main() {
    console.log("=== Restaurant Booking System Demo ===\n");

    // Create service with BestFit strategy
    const service = new BookingService(new BestFitStrategy());

    // Add tables
    console.log("--- Adding Tables ---");
    const t1 = service.addTable(2, TableType.INDOOR);
    const t2 = service.addTable(4, TableType.INDOOR);
    const t3 = service.addTable(6, TableType.OUTDOOR);
    const t4 = service.addTable(8, TableType.VIP);
    console.log(`Added: ${t1}, ${t2}, ${t3}, ${t4}`);

    // Define time slots
    const fridayDinner = new TimeSlot("2025-01-10", "19:00", "21:00");
    const fridayLate = new TimeSlot("2025-01-10", "20:00", "22:00");

    // Book tables - BestFit assigns smallest fitting table
    console.log("\n--- Booking with BestFit Strategy ---");
    const r1 = await service.bookTable("Alice", 2, fridayDinner);
    const r2 = await service.bookTable("Bob", 4, fridayDinner);
    const r3 = await service.bookTable("Charlie", 5, fridayDinner);
    const r4 = await service.bookTable("Diana", 7, fridayDinner);

    // This should go to waitlist (all tables booked for overlapping slot)
    console.log("\n--- Conflict Detection (overlapping slot) ---");
    const r5 = await service.bookTable("Eve", 2, fridayLate);

    // Show waitlist
    console.log("\n--- Waitlist for Friday Late ---");
    service.getWaitlist(fridayLate).forEach(e => console.log(`  ${e.toString()}`));

    // Cancel Alice's booking - should auto-promote Eve
    console.log("\n--- Cancel Alice (auto-promotes waitlist) ---");
    await service.cancelBooking(r1.booking.id);

    // Demonstrate state transitions
    console.log("\n--- State Transitions ---");
    service.seatGuests(r2.booking.id);
    service.completeBooking(r2.booking.id);

    // Switch to FirstFit strategy
    console.log("\n--- Switch to FirstFit Strategy ---");
    service.setStrategy(new FirstFitStrategy());
    const saturdayDinner = new TimeSlot("2025-01-11", "19:00", "21:00");
    const r6 = await service.bookTable("Frank", 2, saturdayDinner);

    // Show available tables
    console.log("\n--- Available tables for Saturday Dinner (party of 2) ---");
    service.getAvailableTables(saturdayDinner, 2).forEach(t => console.log(`  ${t.toString()}`));

    console.log("\n=== Demo Complete ===");
}

main();