15. Library Management System Intermediate

interface FineStrategy {
  Money calculateFine(Loan loan);
}

class Library {
  List<Book> search(String query);
  Loan checkout(Member member, String barcode);
  void returnItem(String barcode);
  void placeHold(Member member, Book book);
}

interface FineStrategy {
  Money calculateFine(Loan loan);
}

class Library {
  List<Book> search(String query);
  Loan checkout(Member member, String barcode);
  void returnItem(String barcode);
  void placeHold(Member member, Book book);
}

class FineStrategy {
public:
  virtual Money calculateFine(const Loan& loan) = 0;
};

class Library {
public:
  std::vector<std::shared_ptr<Book>> search(const std::string& query);
  std::shared_ptr<Loan> checkout(std::shared_ptr<Member> member, const std::string& barcode);
  void returnItem(const std::string& barcode);
  void placeHold(std::shared_ptr<Member> member, std::shared_ptr<Book> book);
};

class FineStrategy {
  calculateFine(loan) { throw new Error('not implemented'); }
}

class Library {
  search(query) {}
  checkout(member, barcode) {}
  returnItem(barcode) {}
  placeHold(member, book) {}
}

interface FineStrategy {
  calculateFine(loan: Loan): Money;
}

class Library {
  search(query: string): Book[] {}
  checkout(member: Member, barcode: string): Loan {}
  returnItem(barcode: string): void {}
  placeHold(member: Member, book: Book): void {}
}

Library.checkout(member, barcode):
  lock(bookItemFor(barcode))
  try:
    item = bookItemFor(barcode)
    if item.status != AVAILABLE: reject
    item.status = CHECKED_OUT
    loan = new Loan(member, item, dueDate = now + loanPeriod(item.book.category))
    return loan
  finally:
    unlock(item)

BookItem.returnItem():
  this.status = AVAILABLE
  holdQueue = holdQueueFor(this.book)
  if holdQueue.hasWaiting():
    nextHold = holdQueue.popNext()
    this.status = ON_HOLD          // reserved for the notified member, not generally available
    notify(nextHold.member, this)

Loan checkout(Member member, String barcode) {
  BookItem item = bookItemFor(barcode);
  lock(item);
  try {
    item = bookItemFor(barcode);
    if (item.getStatus() != Status.AVAILABLE) return null;   // reject
    item.setStatus(Status.CHECKED_OUT);
    Loan loan = new Loan(member, item, now().plus(loanPeriod(item.getBook().getCategory())));
    return loan;
  } finally {
    unlock(item);
  }
}

void returnItem() {
  this.status = Status.AVAILABLE;
  HoldQueue holdQueue = holdQueueFor(this.book);
  if (holdQueue.hasWaiting()) {
    Hold nextHold = holdQueue.popNext();
    this.status = Status.ON_HOLD;          // reserved for the notified member, not generally available
    notify(nextHold.getMember(), this);
  }
}

std::shared_ptr<Loan> Library::checkout(std::shared_ptr<Member> member, const std::string& barcode) {
  auto item = bookItemFor(barcode);
  lock(item);
  try {
    item = bookItemFor(barcode);
    if (item->status != Status::AVAILABLE) return nullptr;   // reject
    item->status = Status::CHECKED_OUT;
    auto loan = std::make_shared<Loan>(member, item, now() + loanPeriod(item->book->category));
    unlock(item);
    return loan;
  } catch (...) {
    unlock(item);
    throw;
  }
}

void BookItem::returnItem() {
  this->status = Status::AVAILABLE;
  auto holdQueue = holdQueueFor(this->book);
  if (holdQueue->hasWaiting()) {
    auto nextHold = holdQueue->popNext();
    this->status = Status::ON_HOLD;          // reserved for the notified member, not generally available
    notify(nextHold->member, shared_from_this());
  }
}

checkout(member, barcode) {
  let item = this.bookItemFor(barcode);
  lock(item);
  try {
    item = this.bookItemFor(barcode);
    if (item.status !== Status.AVAILABLE) return null;   // reject
    item.status = Status.CHECKED_OUT;
    const loan = new Loan(member, item, addDuration(now(), loanPeriod(item.book.category)));
    return loan;
  } finally {
    unlock(item);
  }
}

returnItem() {
  this.status = Status.AVAILABLE;
  const holdQueue = holdQueueFor(this.book);
  if (holdQueue.hasWaiting()) {
    const nextHold = holdQueue.popNext();
    this.status = Status.ON_HOLD;          // reserved for the notified member, not generally available
    notify(nextHold.member, this);
  }
}

checkout(member: Member, barcode: string): Loan | null {
  let item = this.bookItemFor(barcode);
  lock(item);
  try {
    item = this.bookItemFor(barcode);
    if (item.status !== Status.AVAILABLE) return null;   // reject
    item.status = Status.CHECKED_OUT;
    const loan = new Loan(member, item, addDuration(now(), loanPeriod(item.book.category)));
    return loan;
  } finally {
    unlock(item);
  }
}

returnItem(): void {
  this.status = Status.AVAILABLE;
  const holdQueue = holdQueueFor(this.book);
  if (holdQueue.hasWaiting()) {
    const nextHold = holdQueue.popNext();
    this.status = Status.ON_HOLD;          // reserved for the notified member, not generally available
    notify(nextHold.member, this);
  }
}

// Library Management System - full LLD implementation (single-file demo).
// No "Concurrency" badge -> single-threaded; the "two members racing the last copy"
// requirement is satisfied by checkout() being one atomic status-check-and-flip step
// against a single BookItem, not by explicit locking primitives.
//
// Design notes:
// - Book (title metadata) vs. BookItem (physical copy) is the central modeling
//   decision: metadata is shared/immutable across copies, status is per-copy and
//   constantly changing.
// - Observer for holds: BookItem.returnItem() notifies the title's HoldQueue, which
//   pops the next Hold in FIFO order and hands the copy to that member - decoupling
//   "a copy became available" from "who reacts to that".
// - Strategy for fines: FineStrategy.calculateFine(loan) isolates rate changes from
//   Loan/Library's record-keeping code.
import java.util.*;

public class p15 {

    enum ItemStatus { AVAILABLE, CHECKED_OUT, ON_HOLD, LOST }
    enum Category { FICTION, NON_FICTION, REFERENCE }
    enum MembershipType { REGULAR, PREMIUM }

    // ---------- Book (title-level metadata) ----------
    static class Book {
        final String isbn, title, author;
        final Category category;
        Book(String isbn, String title, String author, Category category) {
            this.isbn = isbn; this.title = title; this.author = author; this.category = category;
        }
    }

    // ---------- BookItem (one physical, lendable copy) ----------
    static class BookItem {
        final String barcode;
        final Book book;
        ItemStatus status = ItemStatus.AVAILABLE;
        Date dueDate;
        final Library library; // back-reference used to reach the right HoldQueue on return

        BookItem(String barcode, Book book, Library library) {
            this.barcode = barcode; this.book = book; this.library = library;
        }

        // Marks the copy checked out; Library owns creating/recording the Loan itself.
        void checkout(Date dueDate) {
            this.status = ItemStatus.CHECKED_OUT;
            this.dueDate = dueDate;
        }

        // Flips back to available, then defers to the title's HoldQueue (Observer) to
        // decide whether this copy should instead go straight to the next waiting member.
        void returnItem() {
            this.status = ItemStatus.AVAILABLE;
            this.dueDate = null;
            HoldQueue queue = library.holdQueueFor(book);
            if (queue != null && queue.hasWaiting()) {
                Hold nextHold = queue.popNext();
                this.status = ItemStatus.ON_HOLD; // reserved, not generally available
                queue.notifyNext(this, nextHold);
            }
        }
    }

    // ---------- Member ----------
    static class Member {
        final String id;
        final MembershipType membershipType;
        final List<Loan> activeLoans = new ArrayList<>();
        final List<Hold> activeHolds = new ArrayList<>();
        Member(String id, MembershipType membershipType) { this.id = id; this.membershipType = membershipType; }
    }

    // ---------- Loan (one active checkout record) ----------
    static class Loan {
        final Member member;
        final BookItem bookItem;
        final Date checkoutDate;
        final Date dueDate;
        boolean returned = false;

        Loan(Member member, BookItem bookItem, Date checkoutDate, Date dueDate) {
            this.member = member; this.bookItem = bookItem; this.checkoutDate = checkoutDate; this.dueDate = dueDate;
        }

        boolean isOverdue(Date asOf) { return !returned && asOf.after(dueDate); }
    }

    // ---------- Hold (one member's place in a title's wait queue) ----------
    static class Hold {
        final Member member;
        final Book book;
        final long timestamp;
        Hold(Member member, Book book, long timestamp) { this.member = member; this.book = book; this.timestamp = timestamp; }
    }

    // ---------- HoldQueue (FIFO wait list + Observer subject for availability) ----------
    static class HoldQueue {
        private final Deque<Hold> queue = new ArrayDeque<>();

        void addHold(Hold hold) { queue.addLast(hold); }
        boolean hasWaiting() { return !queue.isEmpty(); }
        Hold popNext() { return queue.pollFirst(); }
        int waitingCount() { return queue.size(); }

        // The "reaction" side of the Observer relationship: BookItem triggers this,
        // HoldQueue decides who gets notified. A real system would email/page the
        // member here; we just print, and record it as satisfied.
        void notifyNext(BookItem item, Hold hold) {
            hold.member.activeHolds.remove(hold);
            System.out.println("  Notifying " + hold.member.id + ": your hold on \"" + item.book.title + "\" is ready (barcode " + item.barcode + ")");
        }
    }

    // ---------- FineStrategy (interface, Strategy) ----------
    interface FineStrategy {
        double calculateFine(Loan loan, Date asOf);
    }

    // Rate depends on both member type and item category - isolated here so a rate
    // change never touches Loan or Library.
    static class StandardFineStrategy implements FineStrategy {
        public double calculateFine(Loan loan, Date asOf) {
            if (!loan.isOverdue(asOf)) return 0.0;
            long overdueDays = (asOf.getTime() - loan.dueDate.getTime()) / (1000L * 60 * 60 * 24) + 1;
            double perDay = loan.bookItem.book.category == Category.REFERENCE ? 1.0 : 0.25;
            if (loan.member.membershipType == MembershipType.PREMIUM) perDay *= 0.5; // premium discount
            return overdueDays * perDay;
        }
    }

    // ---------- Catalog (search index over Book entries) ----------
    static class Catalog {
        private final List<Book> books = new ArrayList<>();
        void addBook(Book book) { books.add(book); }

        List<Book> search(String query) {
            String q = query.toLowerCase();
            List<Book> results = new ArrayList<>();
            for (Book b : books) {
                if (b.title.toLowerCase().contains(q) || b.author.toLowerCase().contains(q)
                        || b.category.name().toLowerCase().contains(q)) {
                    results.add(b);
                }
            }
            return results;
        }
    }

    // ---------- Library (facade) ----------
    static class Library {
        final Catalog catalog = new Catalog();
        final Map<String, BookItem> itemsByBarcode = new HashMap<>();
        final Map<String, Loan> activeLoanByBarcode = new HashMap<>();
        final Map<String, HoldQueue> holdQueuesByIsbn = new HashMap<>();
        final FineStrategy fineStrategy;
        private static final long LOAN_PERIOD_MILLIS = 14L * 24 * 60 * 60 * 1000; // 14 days, flat for demo

        Library(FineStrategy fineStrategy) { this.fineStrategy = fineStrategy; }

        void addBookItem(BookItem item) { itemsByBarcode.put(item.barcode, item); }

        HoldQueue holdQueueFor(Book book) { return holdQueuesByIsbn.get(book.isbn); }

        List<Book> search(String query) { return catalog.search(query); }

        // Single atomic status-check-and-flip against one BookItem - this is exactly
        // what stops two members both succeeding against what they each believe is
        // "the last copy".
        Loan checkout(Member member, String barcode) {
            BookItem item = itemsByBarcode.get(barcode);
            if (item == null) throw new IllegalArgumentException("No such item: " + barcode);
            if (item.status != ItemStatus.AVAILABLE) return null; // reject: not free to check out

            Date due = new Date(System.currentTimeMillis() + LOAN_PERIOD_MILLIS);
            item.checkout(due);
            Loan loan = new Loan(member, item, new Date(), due);
            member.activeLoans.add(loan);
            activeLoanByBarcode.put(barcode, loan);
            return loan;
        }

        void returnItem(String barcode) {
            BookItem item = itemsByBarcode.get(barcode);
            if (item == null) throw new IllegalArgumentException("No such item: " + barcode);
            Loan loan = activeLoanByBarcode.remove(barcode);
            if (loan != null) {
                loan.returned = true;
                loan.member.activeLoans.remove(loan);
            }
            item.returnItem(); // triggers the HoldQueue Observer hook internally
        }

        double calculateFine(Loan loan) { return fineStrategy.calculateFine(loan, new Date()); }

        // Places a hold only when no copy is free; otherwise the member should just checkout.
        void placeHold(Member member, Book book) {
            HoldQueue queue = holdQueuesByIsbn.computeIfAbsent(book.isbn, k -> new HoldQueue());
            Hold hold = new Hold(member, book, System.currentTimeMillis());
            queue.addHold(hold);
            member.activeHolds.add(hold);
        }
    }

    // ---------- Demo ----------
    public static void main(String[] args) throws InterruptedException {
        Library library = new Library(new StandardFineStrategy());

        Book book = new Book("978-1", "The Pragmatic Programmer", "Hunt & Thomas", Category.NON_FICTION);
        library.catalog.addBook(book);
        BookItem copy1 = new BookItem("BC-1", book, library);
        BookItem copy2 = new BookItem("BC-2", book, library);
        library.addBookItem(copy1);
        library.addBookItem(copy2);

        System.out.println("Search 'pragmatic': " + library.search("pragmatic").size() + " result(s)");

        Member alice = new Member("alice", MembershipType.REGULAR);
        Member bob = new Member("bob", MembershipType.PREMIUM);
        Member carol = new Member("carol", MembershipType.REGULAR);

        Loan loan1 = library.checkout(alice, "BC-1");
        Loan loan2 = library.checkout(bob, "BC-2");
        System.out.println("Alice checked out BC-1: " + (loan1 != null));
        System.out.println("Bob checked out BC-2: " + (loan2 != null));

        // Both copies are gone now - Carol must queue for a hold instead of a 3rd checkout.
        Loan failedLoan = library.checkout(carol, "BC-1");
        System.out.println("Carol tries BC-1 while checked out: " + (failedLoan == null ? "rejected as expected" : "unexpectedly succeeded"));
        library.placeHold(carol, book);
        System.out.println("Carol placed a hold; queue size: " + library.holdQueueFor(book).waitingCount());

        // Alice returns her copy -> Observer hook should notify Carol and reserve BC-1 for her.
        library.returnItem("BC-1");
        System.out.println("BC-1 status after return: " + copy1.status);

        // Simulate an overdue fine: backdate the due date on Bob's loan and price it.
        loan2.dueDate.setTime(System.currentTimeMillis() - (3L * 24 * 60 * 60 * 1000));
        double fine = library.calculateFine(loan2);
        System.out.println("Bob's fine for 3 overdue days (premium discount applied): $" + fine);
    }
}

// Library Management System - full LLD implementation (single-file demo).
// No "Concurrency" badge -> single-threaded; the "two members racing the last copy"
// requirement is satisfied by checkout() being one atomic status-check-and-flip step
// against a single BookItem, not by explicit locking primitives.
//
// Design notes:
// - Book (title metadata) vs. BookItem (physical copy) is the central modeling
//   decision: metadata is shared/immutable across copies, status is per-copy.
// - Observer for holds: BookItem::returnItem() notifies the title's HoldQueue, which
//   pops the next Hold in FIFO order and hands the copy to that member.
// - Strategy for fines: FineStrategy::calculateFine(loan) isolates rate changes from
//   Loan/Library's record-keeping code.
#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <unordered_map>
#include <memory>
#include <algorithm>
#include <chrono>
#include <stdexcept>

using namespace std;
using Clock = chrono::system_clock;

enum class ItemStatus { AVAILABLE, CHECKED_OUT, ON_HOLD, LOST };
enum class Category { FICTION, NON_FICTION, REFERENCE };
enum class MembershipType { REGULAR, PREMIUM };

static string toString(ItemStatus s) {
    switch (s) {
        case ItemStatus::AVAILABLE: return "AVAILABLE";
        case ItemStatus::CHECKED_OUT: return "CHECKED_OUT";
        case ItemStatus::ON_HOLD: return "ON_HOLD";
        case ItemStatus::LOST: return "LOST";
    }
    return "?";
}

// ---------- Book (title-level metadata) ----------
struct Book {
    string isbn, title, author;
    Category category;
};

class Library; // fwd decl

// ---------- BookItem (one physical, lendable copy) ----------
class BookItem {
public:
    string barcode;
    Book* book;
    ItemStatus status = ItemStatus::AVAILABLE;
    Clock::time_point dueDate;
    Library* library; // back-reference used to reach the right HoldQueue on return

    BookItem(string barcode, Book* book, Library* library) : barcode(std::move(barcode)), book(book), library(library) {}

    void checkout(Clock::time_point due) {
        status = ItemStatus::CHECKED_OUT;
        dueDate = due;
    }

    void returnItem(); // defined after Library, since it dispatches to Library's HoldQueue
};

// ---------- Member ----------
struct Loan;
struct Hold;

struct Member {
    string id;
    MembershipType membershipType;
    vector<Loan*> activeLoans;
    vector<Hold*> activeHolds;
};

// ---------- Loan (one active checkout record) ----------
struct Loan {
    Member* member;
    BookItem* bookItem;
    Clock::time_point checkoutDate;
    Clock::time_point dueDate;
    bool returned = false;

    bool isOverdue(Clock::time_point asOf) const { return !returned && asOf > dueDate; }
};

// ---------- Hold (one member's place in a title's wait queue) ----------
struct Hold {
    Member* member;
    Book* book;
    long long timestamp;
};

// ---------- HoldQueue (FIFO wait list + Observer subject for availability) ----------
class HoldQueue {
    deque<unique_ptr<Hold>> queue;
public:
    void addHold(unique_ptr<Hold> hold) { queue.push_back(std::move(hold)); }
    bool hasWaiting() const { return !queue.empty(); }
    unique_ptr<Hold> popNext() {
        auto h = std::move(queue.front());
        queue.pop_front();
        return h;
    }
    size_t waitingCount() const { return queue.size(); }

    // BookItem triggers this; HoldQueue decides who gets notified.
    void notifyNext(BookItem& item, Hold& hold) {
        auto& holds = hold.member->activeHolds;
        holds.erase(remove(holds.begin(), holds.end(), &hold), holds.end());
        cout << "  Notifying " << hold.member->id << ": your hold on \"" << item.book->title
             << "\" is ready (barcode " << item.barcode << ")\n";
    }
};

// ---------- FineStrategy (interface, Strategy) ----------
class FineStrategy {
public:
    virtual ~FineStrategy() = default;
    virtual double calculateFine(const Loan& loan, Clock::time_point asOf) = 0;
};

class StandardFineStrategy : public FineStrategy {
public:
    double calculateFine(const Loan& loan, Clock::time_point asOf) override {
        if (!loan.isOverdue(asOf)) return 0.0;
        long long overdueDays = chrono::duration_cast<chrono::hours>(asOf - loan.dueDate).count() / 24 + 1;
        double perDay = loan.bookItem->book->category == Category::REFERENCE ? 1.0 : 0.25;
        if (loan.member->membershipType == MembershipType::PREMIUM) perDay *= 0.5; // premium discount
        return overdueDays * perDay;
    }
};

// ---------- Catalog (search index over Book entries) ----------
class Catalog {
    vector<Book*> books;
public:
    void addBook(Book* book) { books.push_back(book); }
    vector<Book*> search(const string& query) const {
        string q = query;
        transform(q.begin(), q.end(), q.begin(), ::tolower);
        vector<Book*> results;
        for (Book* b : books) {
            string title = b->title, author = b->author;
            transform(title.begin(), title.end(), title.begin(), ::tolower);
            transform(author.begin(), author.end(), author.begin(), ::tolower);
            if (title.find(q) != string::npos || author.find(q) != string::npos) results.push_back(b);
        }
        return results;
    }
};

// ---------- Library (facade) ----------
class Library {
public:
    Catalog catalog;
    unordered_map<string, BookItem*> itemsByBarcode;
    unordered_map<string, Loan*> activeLoanByBarcode;
    unordered_map<string, unique_ptr<HoldQueue>> holdQueuesByIsbn;
    unique_ptr<FineStrategy> fineStrategy;
    vector<unique_ptr<Loan>> loanStorage; // owns Loan lifetimes

    static constexpr int LOAN_PERIOD_DAYS = 14;

    explicit Library(unique_ptr<FineStrategy> fineStrategy) : fineStrategy(std::move(fineStrategy)) {}

    void addBookItem(BookItem* item) { itemsByBarcode[item->barcode] = item; }

    HoldQueue* holdQueueFor(const Book& book) {
        auto it = holdQueuesByIsbn.find(book.isbn);
        return it == holdQueuesByIsbn.end() ? nullptr : it->second.get();
    }

    vector<Book*> search(const string& query) { return catalog.search(query); }

    // Single atomic status-check-and-flip against one BookItem.
    Loan* checkout(Member* member, const string& barcode) {
        auto it = itemsByBarcode.find(barcode);
        if (it == itemsByBarcode.end()) throw invalid_argument("No such item: " + barcode);
        BookItem* item = it->second;
        if (item->status != ItemStatus::AVAILABLE) return nullptr; // reject: not free to check out

        auto due = Clock::now() + chrono::hours(24 * LOAN_PERIOD_DAYS);
        item->checkout(due);
        auto loan = make_unique<Loan>();
        loan->member = member; loan->bookItem = item; loan->checkoutDate = Clock::now(); loan->dueDate = due;
        Loan* raw = loan.get();
        member->activeLoans.push_back(raw);
        activeLoanByBarcode[barcode] = raw;
        loanStorage.push_back(std::move(loan));
        return raw;
    }

    void returnItem(const string& barcode) {
        auto it = itemsByBarcode.find(barcode);
        if (it == itemsByBarcode.end()) throw invalid_argument("No such item: " + barcode);
        BookItem* item = it->second;
        auto loanIt = activeLoanByBarcode.find(barcode);
        if (loanIt != activeLoanByBarcode.end()) {
            Loan* loan = loanIt->second;
            loan->returned = true;
            auto& loans = loan->member->activeLoans;
            loans.erase(remove(loans.begin(), loans.end(), loan), loans.end());
            activeLoanByBarcode.erase(loanIt);
        }
        item->returnItem(); // triggers the HoldQueue Observer hook internally
    }

    double calculateFine(const Loan& loan) { return fineStrategy->calculateFine(loan, Clock::now()); }

    void placeHold(Member* member, Book* book) {
        auto& queue = holdQueuesByIsbn[book->isbn];
        if (!queue) queue = make_unique<HoldQueue>();
        auto hold = make_unique<Hold>();
        hold->member = member; hold->book = book;
        hold->timestamp = chrono::duration_cast<chrono::milliseconds>(Clock::now().time_since_epoch()).count();
        member->activeHolds.push_back(hold.get());
        queue->addHold(std::move(hold));
    }
};

void BookItem::returnItem() {
    status = ItemStatus::AVAILABLE;
    HoldQueue* queue = library->holdQueueFor(*book);
    if (queue != nullptr && queue->hasWaiting()) {
        unique_ptr<Hold> nextHold = queue->popNext();
        status = ItemStatus::ON_HOLD; // reserved, not generally available
        queue->notifyNext(*this, *nextHold);
    }
}

// ---------- Demo ----------
int main() {
    Library library(make_unique<StandardFineStrategy>());

    Book book{"978-1", "The Pragmatic Programmer", "Hunt & Thomas", Category::NON_FICTION};
    library.catalog.addBook(&book);
    BookItem copy1("BC-1", &book, &library);
    BookItem copy2("BC-2", &book, &library);
    library.addBookItem(&copy1);
    library.addBookItem(&copy2);

    cout << "Search 'pragmatic': " << library.search("pragmatic").size() << " result(s)\n";

    Member alice{"alice", MembershipType::REGULAR, {}, {}};
    Member bob{"bob", MembershipType::PREMIUM, {}, {}};
    Member carol{"carol", MembershipType::REGULAR, {}, {}};

    Loan* loan1 = library.checkout(&alice, "BC-1");
    Loan* loan2 = library.checkout(&bob, "BC-2");
    cout << "Alice checked out BC-1: " << (loan1 != nullptr ? "true" : "false") << "\n";
    cout << "Bob checked out BC-2: " << (loan2 != nullptr ? "true" : "false") << "\n";

    Loan* failedLoan = library.checkout(&carol, "BC-1");
    cout << "Carol tries BC-1 while checked out: " << (failedLoan == nullptr ? "rejected as expected" : "unexpectedly succeeded") << "\n";
    library.placeHold(&carol, &book);
    cout << "Carol placed a hold; queue size: " << library.holdQueueFor(book)->waitingCount() << "\n";

    library.returnItem("BC-1");
    cout << "BC-1 status after return: " << toString(copy1.status) << "\n";

    // Simulate an overdue fine: backdate Bob's due date and price it.
    loan2->dueDate = Clock::now() - chrono::hours(24 * 3);
    double fine = library.calculateFine(*loan2);
    cout << "Bob's fine for 3 overdue days (premium discount applied): $" << fine << "\n";
    return 0;
}

// Library Management System - full LLD implementation (single-file demo, Node/CommonJS).
// No "Concurrency" badge -> single-threaded; the "two members racing the last copy"
// requirement is satisfied by checkout() being one atomic status-check-and-flip step
// against a single BookItem, not by explicit locking primitives.
//
// Design notes:
// - Book (title metadata) vs. BookItem (physical copy) is the central modeling
//   decision: metadata is shared/immutable across copies, status is per-copy.
// - Observer for holds: BookItem.returnItem() notifies the title's HoldQueue, which
//   pops the next Hold in FIFO order and hands the copy to that member.
// - Strategy for fines: FineStrategy.calculateFine(loan) isolates rate changes from
//   Loan/Library's record-keeping code.

const ItemStatus = Object.freeze({ AVAILABLE: 'AVAILABLE', CHECKED_OUT: 'CHECKED_OUT', ON_HOLD: 'ON_HOLD', LOST: 'LOST' });
const Category = Object.freeze({ FICTION: 'FICTION', NON_FICTION: 'NON_FICTION', REFERENCE: 'REFERENCE' });
const MembershipType = Object.freeze({ REGULAR: 'REGULAR', PREMIUM: 'PREMIUM' });

const DAY_MS = 24 * 60 * 60 * 1000;

// ---------- Book (title-level metadata) ----------
class Book {
  constructor(isbn, title, author, category) {
    this.isbn = isbn; this.title = title; this.author = author; this.category = category;
  }
}

// ---------- BookItem (one physical, lendable copy) ----------
class BookItem {
  constructor(barcode, book, library) {
    this.barcode = barcode;
    this.book = book;
    this.library = library; // back-reference used to reach the right HoldQueue on return
    this.status = ItemStatus.AVAILABLE;
    this.dueDate = null;
  }

  checkout(dueDate) {
    this.status = ItemStatus.CHECKED_OUT;
    this.dueDate = dueDate;
  }

  // Flips back to available, then defers to the title's HoldQueue (Observer) to decide
  // whether this copy should instead go straight to the next waiting member.
  returnItem() {
    this.status = ItemStatus.AVAILABLE;
    this.dueDate = null;
    const queue = this.library.holdQueueFor(this.book);
    if (queue != null && queue.hasWaiting()) {
      const nextHold = queue.popNext();
      this.status = ItemStatus.ON_HOLD; // reserved, not generally available
      queue.notifyNext(this, nextHold);
    }
  }
}

// ---------- Member ----------
class Member {
  constructor(id, membershipType) {
    this.id = id;
    this.membershipType = membershipType;
    this.activeLoans = [];
    this.activeHolds = [];
  }
}

// ---------- Loan (one active checkout record) ----------
class Loan {
  constructor(member, bookItem, checkoutDate, dueDate) {
    this.member = member;
    this.bookItem = bookItem;
    this.checkoutDate = checkoutDate;
    this.dueDate = dueDate;
    this.returned = false;
  }
  isOverdue(asOf) { return !this.returned && asOf.getTime() > this.dueDate.getTime(); }
}

// ---------- Hold (one member's place in a title's wait queue) ----------
class Hold {
  constructor(member, book, timestamp) { this.member = member; this.book = book; this.timestamp = timestamp; }
}

// ---------- HoldQueue (FIFO wait list + Observer subject for availability) ----------
class HoldQueue {
  constructor() { this.queue = []; }
  addHold(hold) { this.queue.push(hold); }
  hasWaiting() { return this.queue.length > 0; }
  popNext() { return this.queue.shift(); }
  waitingCount() { return this.queue.length; }

  // BookItem triggers this; HoldQueue decides who gets notified.
  notifyNext(item, hold) {
    hold.member.activeHolds = hold.member.activeHolds.filter((h) => h !== hold);
    console.log(`  Notifying ${hold.member.id}: your hold on "${item.book.title}" is ready (barcode ${item.barcode})`);
  }
}

// ---------- FineStrategy (interface, Strategy) ----------
class FineStrategy {
  calculateFine(_loan, _asOf) { throw new Error('not implemented'); }
}

class StandardFineStrategy extends FineStrategy {
  calculateFine(loan, asOf) {
    if (!loan.isOverdue(asOf)) return 0.0;
    const overdueDays = Math.floor((asOf.getTime() - loan.dueDate.getTime()) / DAY_MS) + 1;
    let perDay = loan.bookItem.book.category === Category.REFERENCE ? 1.0 : 0.25;
    if (loan.member.membershipType === MembershipType.PREMIUM) perDay *= 0.5; // premium discount
    return overdueDays * perDay;
  }
}

// ---------- Catalog (search index over Book entries) ----------
class Catalog {
  constructor() { this.books = []; }
  addBook(book) { this.books.push(book); }
  search(query) {
    const q = query.toLowerCase();
    return this.books.filter((b) =>
      b.title.toLowerCase().includes(q) || b.author.toLowerCase().includes(q) || b.category.toLowerCase().includes(q));
  }
}

// ---------- Library (facade) ----------
class Library {
  constructor(fineStrategy) {
    this.catalog = new Catalog();
    this.itemsByBarcode = new Map();
    this.activeLoanByBarcode = new Map();
    this.holdQueuesByIsbn = new Map();
    this.fineStrategy = fineStrategy;
  }

  static LOAN_PERIOD_MS = 14 * DAY_MS; // 14 days, flat for demo

  addBookItem(item) { this.itemsByBarcode.set(item.barcode, item); }

  holdQueueFor(book) { return this.holdQueuesByIsbn.get(book.isbn); }

  search(query) { return this.catalog.search(query); }

  // Single atomic status-check-and-flip against one BookItem - this is exactly what
  // stops two members both succeeding against what they each believe is "the last copy".
  checkout(member, barcode) {
    const item = this.itemsByBarcode.get(barcode);
    if (!item) throw new Error(`No such item: ${barcode}`);
    if (item.status !== ItemStatus.AVAILABLE) return null; // reject: not free to check out

    const due = new Date(Date.now() + Library.LOAN_PERIOD_MS);
    item.checkout(due);
    const loan = new Loan(member, item, new Date(), due);
    member.activeLoans.push(loan);
    this.activeLoanByBarcode.set(barcode, loan);
    return loan;
  }

  returnItem(barcode) {
    const item = this.itemsByBarcode.get(barcode);
    if (!item) throw new Error(`No such item: ${barcode}`);
    const loan = this.activeLoanByBarcode.get(barcode);
    if (loan) {
      loan.returned = true;
      loan.member.activeLoans = loan.member.activeLoans.filter((l) => l !== loan);
      this.activeLoanByBarcode.delete(barcode);
    }
    item.returnItem(); // triggers the HoldQueue Observer hook internally
  }

  calculateFine(loan) { return this.fineStrategy.calculateFine(loan, new Date()); }

  // Places a hold only when no copy is free; otherwise the member should just checkout.
  placeHold(member, book) {
    if (!this.holdQueuesByIsbn.has(book.isbn)) this.holdQueuesByIsbn.set(book.isbn, new HoldQueue());
    const queue = this.holdQueuesByIsbn.get(book.isbn);
    const hold = new Hold(member, book, Date.now());
    queue.addHold(hold);
    member.activeHolds.push(hold);
  }
}

// ---------- Demo ----------
function main() {
  const library = new Library(new StandardFineStrategy());

  const book = new Book('978-1', 'The Pragmatic Programmer', 'Hunt & Thomas', Category.NON_FICTION);
  library.catalog.addBook(book);
  const copy1 = new BookItem('BC-1', book, library);
  const copy2 = new BookItem('BC-2', book, library);
  library.addBookItem(copy1);
  library.addBookItem(copy2);

  console.log(`Search 'pragmatic': ${library.search('pragmatic').length} result(s)`);

  const alice = new Member('alice', MembershipType.REGULAR);
  const bob = new Member('bob', MembershipType.PREMIUM);
  const carol = new Member('carol', MembershipType.REGULAR);

  const loan1 = library.checkout(alice, 'BC-1');
  const loan2 = library.checkout(bob, 'BC-2');
  console.log('Alice checked out BC-1:', loan1 !== null);
  console.log('Bob checked out BC-2:', loan2 !== null);

  const failedLoan = library.checkout(carol, 'BC-1');
  console.log('Carol tries BC-1 while checked out:', failedLoan === null ? 'rejected as expected' : 'unexpectedly succeeded');
  library.placeHold(carol, book);
  console.log('Carol placed a hold; queue size:', library.holdQueueFor(book).waitingCount());

  library.returnItem('BC-1');
  console.log('BC-1 status after return:', copy1.status);

  // Simulate an overdue fine: backdate Bob's due date and price it.
  loan2.dueDate = new Date(Date.now() - 3 * DAY_MS);
  const fine = library.calculateFine(loan2);
  console.log('Bob\'s fine for 3 overdue days (premium discount applied): $' + fine);
}

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

module.exports = {
  ItemStatus, Category, MembershipType, Book, BookItem, Member, Loan, Hold, HoldQueue,
  FineStrategy, StandardFineStrategy, Catalog, Library,
};

// Library Management System - full LLD implementation (single-file demo).
// No "Concurrency" badge -> single-threaded; the "two members racing the last copy"
// requirement is satisfied by checkout() being one atomic status-check-and-flip step
// against a single BookItem, not by explicit locking primitives.
//
// Design notes:
// - Book (title metadata) vs. BookItem (physical copy) is the central modeling
//   decision: metadata is shared/immutable across copies, status is per-copy.
// - Observer for holds: BookItem.returnItem() notifies the title's HoldQueue, which
//   pops the next Hold in FIFO order and hands the copy to that member.
// - Strategy for fines: FineStrategy.calculateFine(loan) isolates rate changes from
//   Loan/Library's record-keeping code.

enum ItemStatus { AVAILABLE = 'AVAILABLE', CHECKED_OUT = 'CHECKED_OUT', ON_HOLD = 'ON_HOLD', LOST = 'LOST' }
enum Category { FICTION = 'FICTION', NON_FICTION = 'NON_FICTION', REFERENCE = 'REFERENCE' }
enum MembershipType { REGULAR = 'REGULAR', PREMIUM = 'PREMIUM' }

const DAY_MS = 24 * 60 * 60 * 1000;

// ---------- Book (title-level metadata) ----------
class Book {
  constructor(public isbn: string, public title: string, public author: string, public category: Category) {}
}

// ---------- BookItem (one physical, lendable copy) ----------
class BookItem {
  status: ItemStatus = ItemStatus.AVAILABLE;
  dueDate: Date | null = null;

  constructor(public barcode: string, public book: Book, private library: Library) {}

  checkout(dueDate: Date): void {
    this.status = ItemStatus.CHECKED_OUT;
    this.dueDate = dueDate;
  }

  // Flips back to available, then defers to the title's HoldQueue (Observer) to decide
  // whether this copy should instead go straight to the next waiting member.
  returnItem(): void {
    this.status = ItemStatus.AVAILABLE;
    this.dueDate = null;
    const queue = this.library.holdQueueFor(this.book);
    if (queue != null && queue.hasWaiting()) {
      const nextHold = queue.popNext() as Hold;
      this.status = ItemStatus.ON_HOLD; // reserved, not generally available
      queue.notifyNext(this, nextHold);
    }
  }
}

// ---------- Member ----------
class Member {
  activeLoans: Loan[] = [];
  activeHolds: Hold[] = [];
  constructor(public id: string, public membershipType: MembershipType) {}
}

// ---------- Loan (one active checkout record) ----------
class Loan {
  returned = false;
  constructor(public member: Member, public bookItem: BookItem, public checkoutDate: Date, public dueDate: Date) {}
  isOverdue(asOf: Date): boolean { return !this.returned && asOf.getTime() > this.dueDate.getTime(); }
}

// ---------- Hold (one member's place in a title's wait queue) ----------
class Hold {
  constructor(public member: Member, public book: Book, public timestamp: number) {}
}

// ---------- HoldQueue (FIFO wait list + Observer subject for availability) ----------
class HoldQueue {
  private queue: Hold[] = [];
  addHold(hold: Hold): void { this.queue.push(hold); }
  hasWaiting(): boolean { return this.queue.length > 0; }
  popNext(): Hold | undefined { return this.queue.shift(); }
  waitingCount(): number { return this.queue.length; }

  // BookItem triggers this; HoldQueue decides who gets notified.
  notifyNext(item: BookItem, hold: Hold): void {
    hold.member.activeHolds = hold.member.activeHolds.filter((h) => h !== hold);
    console.log(`  Notifying ${hold.member.id}: your hold on "${item.book.title}" is ready (barcode ${item.barcode})`);
  }
}

// ---------- FineStrategy (interface, Strategy) ----------
interface FineStrategy {
  calculateFine(loan: Loan, asOf: Date): number;
}

class StandardFineStrategy implements FineStrategy {
  calculateFine(loan: Loan, asOf: Date): number {
    if (!loan.isOverdue(asOf)) return 0.0;
    const overdueDays = Math.floor((asOf.getTime() - loan.dueDate.getTime()) / DAY_MS) + 1;
    let perDay = loan.bookItem.book.category === Category.REFERENCE ? 1.0 : 0.25;
    if (loan.member.membershipType === MembershipType.PREMIUM) perDay *= 0.5; // premium discount
    return overdueDays * perDay;
  }
}

// ---------- Catalog (search index over Book entries) ----------
class Catalog {
  private books: Book[] = [];
  addBook(book: Book): void { this.books.push(book); }
  search(query: string): Book[] {
    const q = query.toLowerCase();
    return this.books.filter((b) =>
      b.title.toLowerCase().includes(q) || b.author.toLowerCase().includes(q) || b.category.toLowerCase().includes(q));
  }
}

// ---------- Library (facade) ----------
class Library {
  catalog = new Catalog();
  private itemsByBarcode = new Map<string, BookItem>();
  private activeLoanByBarcode = new Map<string, Loan>();
  private holdQueuesByIsbn = new Map<string, HoldQueue>();
  private static readonly LOAN_PERIOD_MS = 14 * DAY_MS; // 14 days, flat for demo

  constructor(private fineStrategy: FineStrategy) {}

  addBookItem(item: BookItem): void { this.itemsByBarcode.set(item.barcode, item); }

  holdQueueFor(book: Book): HoldQueue | undefined { return this.holdQueuesByIsbn.get(book.isbn); }

  search(query: string): Book[] { return this.catalog.search(query); }

  // Single atomic status-check-and-flip against one BookItem - this is exactly what
  // stops two members both succeeding against what they each believe is "the last copy".
  checkout(member: Member, barcode: string): Loan | null {
    const item = this.itemsByBarcode.get(barcode);
    if (!item) throw new Error(`No such item: ${barcode}`);
    if (item.status !== ItemStatus.AVAILABLE) return null; // reject: not free to check out

    const due = new Date(Date.now() + Library.LOAN_PERIOD_MS);
    item.checkout(due);
    const loan = new Loan(member, item, new Date(), due);
    member.activeLoans.push(loan);
    this.activeLoanByBarcode.set(barcode, loan);
    return loan;
  }

  returnItem(barcode: string): void {
    const item = this.itemsByBarcode.get(barcode);
    if (!item) throw new Error(`No such item: ${barcode}`);
    const loan = this.activeLoanByBarcode.get(barcode);
    if (loan) {
      loan.returned = true;
      loan.member.activeLoans = loan.member.activeLoans.filter((l) => l !== loan);
      this.activeLoanByBarcode.delete(barcode);
    }
    item.returnItem(); // triggers the HoldQueue Observer hook internally
  }

  calculateFine(loan: Loan): number { return this.fineStrategy.calculateFine(loan, new Date()); }

  // Places a hold only when no copy is free; otherwise the member should just checkout.
  placeHold(member: Member, book: Book): void {
    if (!this.holdQueuesByIsbn.has(book.isbn)) this.holdQueuesByIsbn.set(book.isbn, new HoldQueue());
    const queue = this.holdQueuesByIsbn.get(book.isbn) as HoldQueue;
    const hold = new Hold(member, book, Date.now());
    queue.addHold(hold);
    member.activeHolds.push(hold);
  }
}

// ---------- Demo ----------
function main(): void {
  const library = new Library(new StandardFineStrategy());

  const book = new Book('978-1', 'The Pragmatic Programmer', 'Hunt & Thomas', Category.NON_FICTION);
  library.catalog.addBook(book);
  const copy1 = new BookItem('BC-1', book, library);
  const copy2 = new BookItem('BC-2', book, library);
  library.addBookItem(copy1);
  library.addBookItem(copy2);

  console.log(`Search 'pragmatic': ${library.search('pragmatic').length} result(s)`);

  const alice = new Member('alice', MembershipType.REGULAR);
  const bob = new Member('bob', MembershipType.PREMIUM);
  const carol = new Member('carol', MembershipType.REGULAR);

  const loan1 = library.checkout(alice, 'BC-1');
  const loan2 = library.checkout(bob, 'BC-2') as Loan;
  console.log('Alice checked out BC-1:', loan1 !== null);
  console.log('Bob checked out BC-2:', loan2 !== null);

  const failedLoan = library.checkout(carol, 'BC-1');
  console.log('Carol tries BC-1 while checked out:', failedLoan === null ? 'rejected as expected' : 'unexpectedly succeeded');
  library.placeHold(carol, book);
  console.log('Carol placed a hold; queue size:', (library.holdQueueFor(book) as HoldQueue).waitingCount());

  library.returnItem('BC-1');
  console.log('BC-1 status after return:', copy1.status);

  // Simulate an overdue fine: backdate Bob's due date and price it.
  loan2.dueDate = new Date(Date.now() - 3 * DAY_MS);
  const fine = library.calculateFine(loan2);
  console.log(`Bob's fine for 3 overdue days (premium discount applied): $${fine}`);
}

main();

export {
  ItemStatus, Category, MembershipType, Book, BookItem, Member, Loan, Hold, HoldQueue,
  FineStrategy, StandardFineStrategy, Catalog, Library,
};