Library Management

import java.util.*;
import java.util.function.BiConsumer;

/*
 * Dates are plain day numbers so the demo is deterministic. Real code uses
 * LocalDate — what matters in the round is that the date is PASSED IN,
 * never read from a clock inside the method.
 */

enum ItemStatus { AVAILABLE, RESERVED, LOANED, LOST, IN_REPAIR }

/** The CATALOGUE RECORD. One per title, however many copies the library owns. */
record Book(String isbn, String title, String author, String subject, int publishedYear) {}

/** ONE PHYSICAL COPY — the thing a member actually carries home. */
final class BookItem {
    final String barcode, isbn, rack;
    final int acquiredOn;
    final long priceMinor;                  // paise — integer minor units, never double
    private ItemStatus status = ItemStatus.AVAILABLE;
    private String heldFor;                 // member id, only while RESERVED

    BookItem(String barcode, String isbn, String rack, int acquiredOn, long priceMinor) {
        this.barcode = barcode; this.isbn = isbn; this.rack = rack;
        this.acquiredOn = acquiredOn; this.priceMinor = priceMinor;
    }

    ItemStatus status()   { return status; }
    String heldFor()      { return heldFor; }
    boolean isAvailable() { return status == ItemStatus.AVAILABLE; }

    // the small state machine — a boolean cannot express five states
    void loanOut() {
        if (status != ItemStatus.AVAILABLE && status != ItemStatus.RESERVED)
            throw new IllegalStateException(barcode + " is " + status);
        status = ItemStatus.LOANED; heldFor = null;
    }
    void shelve()                 { status = ItemStatus.AVAILABLE; heldFor = null; }
    void holdFor(String memberId) { status = ItemStatus.RESERVED;  heldFor = memberId; }
    void markLost()               { status = ItemStatus.LOST;      heldFor = null; }
    void sendForRepair()          { status = ItemStatus.IN_REPAIR; heldFor = null; }
}

/** The relationship IS an object. The closed ones are the library's memory. */
final class BookLending {
    static final int LOAN_DAYS = 14;
    final String barcode, memberId;
    final int issuedOn, dueOn;
    private Integer returnedOn;
    private long fineMinor;

    BookLending(String barcode, String memberId, int issuedOn) {
        this.barcode = barcode; this.memberId = memberId;
        this.issuedOn = issuedOn; this.dueOn = issuedOn + LOAN_DAYS;
    }
    boolean isOpen()      { return returnedOn == null; }
    long daysLate(int on) { return Math.max(0, on - dueOn); }
    long fineMinor()      { return fineMinor; }
    void close(int on, long fine) { returnedOn = on; fineMinor = fine; }
}

final class Money {
    static String of(long minor) { return "Rs." + (minor / 100) + "." + String.format("%02d", minor % 100); }
}

/* ---------------- the strategy seam: pricing lateness ---------------- */

interface FinePolicy {
    long fineFor(long daysLate, long itemPriceMinor);   // daysLate is already clamped at 0
    String label();
}

final class FlatPerDayFine implements FinePolicy {
    private final long perDayMinor;
    FlatPerDayFine(long perDayMinor) { this.perDayMinor = perDayMinor; }
    public long fineFor(long daysLate, long price) { return daysLate * perDayMinor; }
    public String label() { return "flat " + Money.of(perDayMinor) + "/day"; }
}

final class SlabFine implements FinePolicy {
    public long fineFor(long daysLate, long price) {
        long gentle = Math.min(daysLate, 7);
        return gentle * 200 + Math.max(0, daysLate - 7) * 1000;
    }
    public String label() { return "slabs 2.00 then 10.00"; }
}

final class CappedFine implements FinePolicy {
    private final FinePolicy inner; private final long capMinor;
    CappedFine(FinePolicy inner, long capMinor) { this.inner = inner; this.capMinor = capMinor; }
    public long fineFor(long daysLate, long price) {
        return Math.min(inner.fineFor(daysLate, price), Math.min(capMinor, price));
    }
    public String label() { return inner.label() + ", capped at " + Money.of(capMinor); }
}

/* ---------------- accounts: two roles, ONE level deep ---------------- */

abstract class Account {
    final String id, name;
    Account(String id, String name) { this.id = id; this.name = name; }
    abstract String role();
}

final class BorrowRefused extends RuntimeException {
    BorrowRefused(String why) { super(why); }
}

final class Member extends Account {
    static final int  MAX_LOANS = 5;
    static final long MAX_FINE_MINOR = 10_000;            // Rs.100.00
    private final List<BookLending> lendings = new ArrayList<>();
    private final int membershipExpiresOn;
    private long fineOwedMinor;

    Member(String id, String name, int membershipExpiresOn) {
        super(id, name); this.membershipExpiresOn = membershipExpiresOn;
    }
    String role() { return "MEMBER"; }

    long openLoans()     { return lendings.stream().filter(BookLending::isOpen).count(); }
    long lateReturns()   { return lendings.stream().filter(l -> !l.isOpen() && l.fineMinor() > 0).count(); }
    long fineOwedMinor() { return fineOwedMinor; }
    List<BookLending> lendings() { return List.copyOf(lendings); }

    /** THE RULE LIVES HERE. The service asks; it does not reach in and decide. */
    void assertCanBorrow(int today) {
        if (today > membershipExpiresOn)
            throw new BorrowRefused(name + ": membership expired on day " + membershipExpiresOn);
        if (openLoans() >= MAX_LOANS)
            throw new BorrowRefused(name + ": loan limit reached (" + MAX_LOANS + " of " + MAX_LOANS + ")");
        if (fineOwedMinor > MAX_FINE_MINOR)
            throw new BorrowRefused(name + ": outstanding fine " + Money.of(fineOwedMinor));
    }
    boolean canBorrow(int today) {
        try { assertCanBorrow(today); return true; } catch (BorrowRefused e) { return false; }
    }
    void addLending(BookLending l) { lendings.add(l); }
    void addFine(long minor)       { fineOwedMinor += minor; }
    void payFine(long minor)       { fineOwedMinor = Math.max(0, fineOwedMinor - minor); }
}

final class Librarian extends Account {
    Librarian(String id, String name) { super(id, name); }
    String role() { return "LIBRARIAN"; }
    void addItem(Library library, BookItem item) { library.catalog().addItem(item); }
    BookItem issueFor(Library library, String isbn, String memberId, int today) {
        return library.issue(isbn, memberId, today);
    }
}

/* ---------------- search: index maps, not a linear scan ---------------- */

final class Catalog {
    private final Map<String, Book> byIsbn = new LinkedHashMap<>();
    private final Map<String, List<Book>> byTitleWord = new HashMap<>();
    private final Map<String, List<Book>> byAuthor = new HashMap<>();
    private final Map<String, List<Book>> bySubject = new HashMap<>();
    private final Map<String, List<BookItem>> itemsByIsbn = new LinkedHashMap<>();
    private final Map<String, BookItem> byBarcode = new HashMap<>();

    void addBook(Book b) {
        byIsbn.put(b.isbn(), b);
        for (String w : b.title().toLowerCase().split(" "))
            byTitleWord.computeIfAbsent(w, k -> new ArrayList<>()).add(b);
        byAuthor.computeIfAbsent(b.author().toLowerCase(), k -> new ArrayList<>()).add(b);
        bySubject.computeIfAbsent(b.subject().toLowerCase(), k -> new ArrayList<>()).add(b);
        itemsByIsbn.computeIfAbsent(b.isbn(), k -> new ArrayList<>());
    }
    void addItem(BookItem item) {
        itemsByIsbn.computeIfAbsent(item.isbn, k -> new ArrayList<>()).add(item);
        byBarcode.put(item.barcode, item);
    }

    Book book(String isbn)         { return byIsbn.get(isbn); }
    Collection<Book> allBooks()    { return byIsbn.values(); }
    List<BookItem> items(String isbn) { return itemsByIsbn.getOrDefault(isbn, List.of()); }
    BookItem item(String barcode) {
        BookItem i = byBarcode.get(barcode);
        if (i == null) throw new IllegalArgumentException("unknown barcode " + barcode);
        return i;
    }

    // SEARCH RETURNS BOOKS — titles. Availability is a COUNT over their items.
    List<Book> searchByTitle(String word)   { return byTitleWord.getOrDefault(word.toLowerCase(), List.of()); }
    List<Book> searchByAuthor(String a)     { return byAuthor.getOrDefault(a.toLowerCase(), List.of()); }
    List<Book> searchBySubject(String s)    { return bySubject.getOrDefault(s.toLowerCase(), List.of()); }
    List<Book> searchByYear(int year) {
        List<Book> out = new ArrayList<>();
        for (Book b : byIsbn.values()) if (b.publishedYear() == year) out.add(b);
        return out;
    }
    long availableCount(String isbn) { return items(isbn).stream().filter(BookItem::isAvailable).count(); }

    // ISSUE RETURNS AN ITEM — a specific copy with a barcode on it.
    Optional<BookItem> firstAvailable(String isbn) {
        return items(isbn).stream().filter(BookItem::isAvailable).findFirst();
    }
    Optional<BookItem> heldFor(String isbn, String memberId) {
        return items(isbn).stream()
                .filter(i -> i.status() == ItemStatus.RESERVED && memberId.equals(i.heldFor()))
                .findFirst();
    }
}

/* ---------------- the facade that orchestrates, and decides nothing ---------------- */

final class Library {
    private final Catalog catalog = new Catalog();
    private final Map<String, Member> members = new LinkedHashMap<>();
    private final Map<String, Deque<String>> reservations = new HashMap<>();
    private final List<BookLending> lendings = new ArrayList<>();
    private final List<BiConsumer<String, String>> listeners = new ArrayList<>();
    private FinePolicy finePolicy;

    Library(FinePolicy finePolicy) { this.finePolicy = finePolicy; }

    Catalog catalog()                      { return catalog; }
    FinePolicy finePolicy()                { return finePolicy; }
    void setFinePolicy(FinePolicy p)       { finePolicy = p; }          // returnItem() unchanged
    void addMember(Member m)               { members.put(m.id, m); }
    void onNotify(BiConsumer<String, String> l) { listeners.add(l); }   // observer, one line

    BookItem issue(String isbn, String memberId, int today) {
        Member m = member(memberId);
        BookItem item = catalog.heldFor(isbn, memberId)                  // your held copy comes first
                .or(() -> catalog.firstAvailable(isbn))
                .orElseThrow(() -> new IllegalStateException("no copy of " + isbn + " is available"));
        m.assertCanBorrow(today);                                        // ASK — do not decide for it
        if (item.status() == ItemStatus.RESERVED) dequeue(isbn, memberId);
        item.loanOut();
        BookLending lending = new BookLending(item.barcode, memberId, today);
        lendings.add(lending);
        m.addLending(lending);
        return item;
    }

    /** Returns the fine charged, in minor units. */
    long returnItem(String barcode, int on) {
        BookItem item = catalog.item(barcode);
        BookLending lending = openLendingFor(barcode);
        long fine = finePolicy.fineFor(lending.daysLate(on), item.priceMinor);
        lending.close(on, fine);
        member(lending.memberId).addFine(fine);

        Deque<String> queue = reservations.get(item.isbn);               // THE BRANCH
        if (queue != null && !queue.isEmpty()) {
            String next = queue.peekFirst();
            item.holdFor(next);                                          // NOT back on the shelf
            notifyMember(next, "copy " + barcode + " of " + item.isbn + " is waiting for you");
        } else {
            item.shelve();
        }
        return fine;
    }

    int reserve(String isbn, String memberId) {
        if (catalog.availableCount(isbn) > 0)
            throw new IllegalStateException("a copy is on the shelf — borrow it instead of reserving");
        Deque<String> q = reservations.computeIfAbsent(isbn, k -> new ArrayDeque<>());
        if (!q.contains(memberId)) q.addLast(memberId);
        return new ArrayList<>(q).indexOf(memberId) + 1;
    }

    /** Allowed only when nobody is waiting for the title. */
    BookLending renew(String barcode, int on) {
        BookItem item = catalog.item(barcode);
        Deque<String> q = reservations.get(item.isbn);
        if (q != null && !q.isEmpty())
            throw new IllegalStateException("cannot renew: " + q.size() + " reservation(s) waiting on " + item.isbn);
        BookLending current = openLendingFor(barcode);
        long fine = finePolicy.fineFor(current.daysLate(on), item.priceMinor);
        current.close(on, fine);
        Member m = member(current.memberId);
        m.addFine(fine);
        BookLending fresh = new BookLending(barcode, current.memberId, on);
        lendings.add(fresh);
        m.addLending(fresh);
        return fresh;
    }

    int queueDepth(String isbn) { return reservations.getOrDefault(isbn, new ArrayDeque<>()).size(); }
    Member member(String id) {
        Member m = members.get(id);
        if (m == null) throw new IllegalArgumentException("unknown member " + id);
        return m;
    }
    Collection<Member> allMembers() { return members.values(); }

    private void dequeue(String isbn, String memberId) {
        Deque<String> q = reservations.get(isbn);
        if (q != null) { q.remove(memberId); if (q.isEmpty()) reservations.remove(isbn); }
    }
    private BookLending openLendingFor(String barcode) {
        for (BookLending l : lendings) if (l.isOpen() && l.barcode.equals(barcode)) return l;
        throw new IllegalStateException(barcode + " is not on loan");
    }
    private void notifyMember(String memberId, String message) {
        for (BiConsumer<String, String> l : listeners) l.accept(memberId, message);
    }
}

public class Main {
    static Library library;

    public static void main(String[] args) {
        library = new Library(new FlatPerDayFine(500));                  // Rs.5.00 a day
        library.onNotify((memberId, msg) -> System.out.println("    notify " + memberId + ": " + msg));

        Catalog catalog = library.catalog();
        catalog.addBook(new Book("978-0-13", "Clean Code", "Robert C. Martin", "software", 2008));
        catalog.addBook(new Book("978-0-20", "The Pragmatic Programmer", "Andrew Hunt", "software", 1999));
        catalog.addBook(new Book("978-0-21", "Design Patterns", "Erich Gamma", "software", 1994));

        Librarian raj = new Librarian("L-1", "Raj");
        raj.addItem(library, new BookItem("B-001", "978-0-13", "R-12", 0, 70000));
        raj.addItem(library, new BookItem("B-002", "978-0-13", "R-12", 0, 70000));
        raj.addItem(library, new BookItem("B-003", "978-0-13", "R-12", 0, 70000));
        raj.addItem(library, new BookItem("P-001", "978-0-20", "R-07", 0, 60000));
        raj.addItem(library, new BookItem("P-002", "978-0-20", "R-07", 0, 60000));
        raj.addItem(library, new BookItem("D-001", "978-0-21", "R-03", 0, 90000));
        raj.addItem(library, new BookItem("D-002", "978-0-21", "R-03", 0, 90000));
        raj.addItem(library, new BookItem("D-003", "978-0-21", "R-03", 0, 90000));

        library.addMember(new Member("M-1", "Asha",  400));
        library.addMember(new Member("M-2", "Ravi",  400));
        library.addMember(new Member("M-3", "Meera", 400));
        library.addMember(new Member("M-4", "Dev",   400));

        System.out.println("=== search: title word \"clean\" — search returns BOOKS ===");
        for (Book b : catalog.searchByTitle("clean")) show(b);

        System.out.println("\n=== day 1: three members borrow the same title ===");
        borrow("978-0-13", "M-1", 1);
        borrow("978-0-13", "M-2", 1);
        borrow("978-0-13", "M-3", 1);
        show(catalog.book("978-0-13"));

        System.out.println("\n=== day 1: Dev wants it too ===");
        borrow("978-0-13", "M-4", 1);
        System.out.println("  reserve -> position " + library.reserve("978-0-13", "M-4") + " in the queue");

        System.out.println("\n=== day 1: Ravi fills his card ===");
        borrow("978-0-20", "M-2", 1);
        borrow("978-0-20", "M-2", 1);
        borrow("978-0-21", "M-2", 1);
        borrow("978-0-21", "M-2", 1);
        borrow("978-0-21", "M-2", 1);          // the 6th — refused by Member, not by the service

        System.out.println("\n=== day 10: Meera tries to renew B-003 ===");
        try { library.renew("B-003", 10); }
        catch (RuntimeException e) { System.out.println("  renew refused: " + e.getMessage()); }

        System.out.println("\n=== day 25: Asha returns B-001, 10 days late ===");
        long fine = library.returnItem("B-001", 25);
        BookItem b001 = catalog.item("B-001");
        System.out.println("  fine " + Money.of(fine) + " (" + library.finePolicy().label() + ")");
        System.out.println("  B-001 -> " + b001.status() + ", held for " + b001.heldFor() + "  <- NOT back on the shelf");
        show(catalog.book("978-0-13"));

        System.out.println("\n=== the same 10 days, priced by three policies ===");
        for (FinePolicy p : List.of(new FlatPerDayFine(500), new SlabFine(),
                                    new CappedFine(new FlatPerDayFine(500), 2000)))
            System.out.printf("  %-34s %s%n", p.label(), Money.of(p.fineFor(10, 70000)));
        System.out.println("  returnItem() was never touched — that is the strategy seam");

        System.out.println("\n=== day 25: Dev collects the copy held for him ===");
        borrow("978-0-13", "M-4", 25);
        System.out.println("  queue depth for 978-0-13 is now " + library.queueDepth("978-0-13"));

        System.out.println("\n=== members ===");
        for (Member m : library.allMembers())
            System.out.printf("  %-6s %-6s loans %d/%d  fine %-10s late returns %d%n",
                    m.id, m.name, m.openLoans(), Member.MAX_LOANS, Money.of(m.fineOwedMinor()), m.lateReturns());
    }

    static void borrow(String isbn, String memberId, int day) {
        try {
            BookItem item = library.issue(isbn, memberId, day);
            System.out.println("  " + memberId + " -> " + item.barcode + " (due day " + (day + BookLending.LOAN_DAYS) + ")");
        } catch (RuntimeException e) {
            System.out.println("  refused: " + e.getMessage());
        }
    }

    static void show(Book b) {
        Catalog c = library.catalog();
        System.out.printf("  %-26s %-18s %d of %d available%n",
                b.title(), b.author(), c.availableCount(b.isbn()), c.items(b.isbn()).size());
    }
}

/* ------------------------- expected output -------------------------
=== search: title word "clean" — search returns BOOKS ===
  Clean Code                 Robert C. Martin   3 of 3 available

=== day 1: three members borrow the same title ===
  M-1 -> B-001 (due day 15)
  M-2 -> B-002 (due day 15)
  M-3 -> B-003 (due day 15)
  Clean Code                 Robert C. Martin   0 of 3 available

=== day 1: Dev wants it too ===
  refused: no copy of 978-0-13 is available
  reserve -> position 1 in the queue

=== day 1: Ravi fills his card ===
  M-2 -> P-001 (due day 15)
  M-2 -> P-002 (due day 15)
  M-2 -> D-001 (due day 15)
  M-2 -> D-002 (due day 15)
  refused: Ravi: loan limit reached (5 of 5)

=== day 10: Meera tries to renew B-003 ===
  renew refused: cannot renew: 1 reservation(s) waiting on 978-0-13

=== day 25: Asha returns B-001, 10 days late ===
    notify M-4: copy B-001 of 978-0-13 is waiting for you
  fine Rs.50.00 (flat Rs.5.00/day)
  B-001 -> RESERVED, held for M-4  <- NOT back on the shelf
  Clean Code                 Robert C. Martin   0 of 3 available

=== the same 10 days, priced by three policies ===
  flat Rs.5.00/day                   Rs.50.00
  slabs 2.00 then 10.00              Rs.44.00
  flat Rs.5.00/day, capped at Rs.20.00 Rs.20.00
  returnItem() was never touched — that is the strategy seam

=== day 25: Dev collects the copy held for him ===
  M-4 -> B-001 (due day 39)
  queue depth for 978-0-13 is now 0

=== members ===
  M-1    Asha   loans 0/5  fine Rs.50.00  late returns 1
  M-2    Ravi   loans 5/5  fine Rs.0.00    late returns 0
  M-3    Meera  loans 1/5  fine Rs.0.00    late returns 0
  M-4    Dev    loans 1/5  fine Rs.0.00    late returns 0
------------------------------------------------------------------- */