classDiagram
    class Library {
      -String name
      -Catalog catalog
      -LendingService lendingService
      +registerMember(Member m) void
      +addInventoryItem(BookItem item) void
    }

    class Catalog {
      -HashMap~String, List~Book~~ titleIndex
      -HashMap~String, List~Book~~ authorIndex
      -HashMap~String, Book~ isbnIndex
      +searchByTitle(String title) List~Book~
      +searchByAuthor(String author) List~Book~
      +searchByIsbn(String isbn) Book
      +addBookItem(BookItem item) void
    }

    class Book {
      -String isbn
      -String title
      -List~Author~ authors
      -String subjectCategory
      -int publicationYear
      -List~BookItem~ inventoryItems
      +getAvailableCount() int
      +findAvailableItem() BookItem
    }

    class BookItem {
      -String barcode
      -ItemStatus status
      -Rack location
      -Book bookReference
      +checkout() boolean
      +checkIn() void
      +markReserved() void
      +setStatus(ItemStatus s) void
    }

    class Rack {
      -int aisleNumber
      -String shelfSection
      -int positionNumber
    }

    class User {
      <<abstract>>
      -String accountId
      -String name
      -String email
    }

    class Member {
      -int totalBooksCheckedOut
      -double outstandingFineBalance
      -AccountStatus status
      -List~BookLoan~ activeLoans
      +canBorrow() boolean
      +incrementLoans() void
      +decrementLoans() void
    }

    class Librarian {
      +addBookItem(BookItem item, Rack r) void
      +overrideAccountStatus(Member m, AccountStatus s) void
    }

    class BookLoan {
      -String loanId
      -BookItem item
      -Member member
      -Date checkoutDate
      -Date dueReturnDate
      -Date actualReturnDate
      +isOverdue(Date current) boolean
      +completeLoan(Date current) void
    }

    class BookReservation {
      -String reservationId
      -Book book
      -Member member
      -Date creationDate
      -ReservationStatus status
    }

    class LendingService {
      -Catalog catalog
      -FineCalculator fineCalculator
      -int MAX_LOANS_PER_USER
      +checkoutBook(String barcode, Member m) BookLoan
      +returnBook(String barcode, Member m) double
      +reserveBook(String isbn, Member m) BookReservation
    }

    class FineCalculator {
      <<interface>>
      +calculateFine(BookLoan loan, Date returnDate) double
    }

    class TieredDailyFineStrategy {
      -double baseDailyRate
      -double graceDays
      +calculateFine(BookLoan loan, Date returnDate) double
    }

    class ItemStatus {
      <<enumeration>>
      AVAILABLE
      ON_LOAN
      RESERVED
      LOST
      MAINTENANCE
    }

    class AccountStatus {
      <<enumeration>>
      ACTIVE
      FROZEN_FINES
      SUSPENDED
      CANCELLED
    }

    Library "1" *-- "1" Catalog
    Library "1" *-- "1" LendingService
    Catalog "1" o-- "*" Book
    Book "1" *-- "1..*" BookItem
    BookItem "1" --> "1" Rack
    BookItem "1" --> "1" ItemStatus
    User <|-- Member
    User <|-- Librarian
    Member "1" --> "1" AccountStatus
    Member "1" o-- "*" BookLoan
    LendingService "1" --> "1" FineCalculator
    FineCalculator <|-- TieredDailyFineStrategy
    BookLoan "1" --> "1" BookItem
    BookLoan "1" --> "1" Member

import time
from enum import Enum, auto
from datetime import datetime, timedelta
from typing import List, Dict, Optional
import threading

class ItemStatus(Enum):
    AVAILABLE = auto()
    ON_LOAN = auto()
    RESERVED = auto()
    LOST = auto()

class AccountStatus(Enum):
    ACTIVE = auto()
    FROZEN_FINES = auto()
    SUSPENDED = auto()

class Rack:
    def __init__(self, aisle: int, shelf: str, position: int):
        self.aisle = aisle
        self.shelf = shelf
        self.position = position
    def __str__(self) -> str:
        return f"Aisle {self.aisle}-Shelf {self.shelf}-{self.position}"

class BookItem:
    """Represents a discrete physical book asset tagged by a unique barcode."""
    def __init__(self, barcode: str, isbn: str, rack: Rack):
        self.barcode = barcode
        self.isbn = isbn
        self.rack = rack
        self.status = ItemStatus.AVAILABLE
        self.lock = threading.Lock()

    def attempt_checkout(self) -> bool:
        """Thread-safe state transition preventing race conditions on single items."""
        with self.lock:
            if self.status == ItemStatus.AVAILABLE:
                self.status = ItemStatus.ON_LOAN
                return True
            return False

    def mark_returned(self, has_pending_reservations: bool):
        with self.lock:
            self.status = ItemStatus.RESERVED if has_pending_reservations else ItemStatus.AVAILABLE

class Book:
    """Represents the abstract metadata defining an intellectual work."""
    def __init__(self, isbn: str, title: str, author: str, category: str):
        self.isbn = isbn
        self.title = title
        self.author = author
        self.category = category
        self.items: List[BookItem] = []

    def add_item(self, item: BookItem):
        self.items.append(item)

    def get_available_count(self) -> int:
        return sum(1 for item in self.items if item.status == ItemStatus.AVAILABLE)

    def fetch_available_item(self) -> Optional[BookItem]:
        for item in self.items:
            if item.status == ItemStatus.AVAILABLE:
                return item
        return None

class Member:
    def __init__(self, account_id: str, name: str):
        self.account_id = account_id
        self.name = name
        self.status = AccountStatus.ACTIVE
        self.active_loan_count = 0
        self.unpaid_fines = 0.0
        self.max_loans = 5
        self.lock = threading.Lock()

    def can_borrow(self) -> bool:
        with self.lock:
            return (self.status == AccountStatus.ACTIVE and 
                    self.active_loan_count < self.max_loans and 
                    self.unpaid_fines <= 10.0)  # Borrow threshold ceiling

    def apply_fine(self, amount: float):
        with self.lock:
            self.unpaid_fines += amount
            if self.unpaid_fines > 10.0:
                self.status = AccountStatus.FROZEN_FINES

class BookLoan:
    def __init__(self, loan_id: str, barcode: str, member_id: str, checkout_date: datetime):
        self.loan_id = loan_id
        self.barcode = barcode
        self.member_id = member_id
        self.checkout_date = checkout_date
        self.due_date = checkout_date + timedelta(days=14) # Default 14 day borrowing window
        self.return_date: Optional[datetime] = None

class FineCalculationStrategy:
    """Strategy architectural pattern allowing flexible billing transformations."""
    def __init__(self, daily_rate: float = 0.50, grace_days: int = 2, max_fine_cap: float = 25.0):
        self.daily_rate = daily_rate
        self.grace_days = grace_days
        self.max_fine_cap = max_fine_cap

    def calculate_fine(self, loan: BookLoan, actual_return: datetime) -> float:
        if actual_return <= loan.due_date:
            return 0.0
        overdue_duration = actual_return - loan.due_date
        overdue_days = overdue_duration.days
        if overdue_days <= self.grace_days:
            return 0.0
        billable_days = overdue_days - self.grace_days
        raw_fine = billable_days * self.daily_rate
        return min(raw_fine, self.max_fine_cap)

class CatalogIndex:
    """In-memory multi-attribute index engine for instantaneous catalog searching."""
    def __init__(self):
        self.isbn_map: Dict[str, Book] = {}
        self.title_index: Dict[str, List[Book]] = {}
        self.author_index: Dict[str, List[Book]] = {}
        self.barcode_item_map: Dict[str, BookItem] = {}

    def register_book(self, book: Book):
        self.isbn_map[book.isbn] = book
        self.title_index.setdefault(book.title.lower(), []).append(book)
        self.author_index.setdefault(book.author.lower(), []).append(book)

    def register_item_barcode(self, item: BookItem):
        self.barcode_item_map[item.barcode] = item

    def search_by_title_prefix(self, query: str) -> List[Book]:
        q_lower = query.lower()
        results = []
        for title_key, books in self.title_index.items():
            if title_key.startswith(q_lower) or q_lower in title_key:
                results.extend(books)
        return list(set(results))

class LibraryService:
    """Core transaction execution orchestrator governing member lending operations."""
    def __init__(self, catalog: CatalogIndex, fine_strategy: FineCalculationStrategy):
        self.catalog = catalog
        self.fine_strategy = fine_strategy
        self.active_loans: Dict[str, BookLoan] = {}
        self.reservations: Dict[str, List[str]] = {} # Map ISBN -> List of Member IDs waiting
        self.lock = threading.Lock()
        self.loan_counter = 1000

    def checkout_item(self, member: Member, isbn: str) -> Optional[BookLoan]:
        if not member.can_borrow():
            print(f"[Checkout Error] Member {member.name} ineligible. Fines: ${member.unpaid_fines:.2f}, Status: {member.status.name}")
            return None

        book = self.catalog.isbn_map.get(isbn)
        if not book:
            print(f"[Checkout Error] ISBN {isbn} unlisted in catalog.")
            return None

        # Fetch available inventory
        item = book.fetch_available_item()
        if not item or not item.attempt_checkout():
            print(f"[Checkout Notice] No available copies of '{book.title}' remain in circulation! Consider reserving.")
            return None

        with self.lock:
            self.loan_counter += 1
            loan_id = f"LN-{self.loan_counter}"
            loan = BookLoan(loan_id, item.barcode, member.account_id, datetime.now())
            self.active_loans[item.barcode] = loan
            member.active_loan_count += 1
            print(f"[Success] Checked out '{book.title}' (Barcode: {item.barcode}) to {member.name}. Due: {loan.due_date.strftime('%Y-%m-%d')}")
            return loan

    def return_item(self, member: Member, barcode: str, return_date: datetime) -> float:
        with self.lock:
            loan = self.active_loans.pop(barcode, None)
            if not loan:
                print(f"[Return Error] No active loan recorded for Barcode {barcode}")
                return 0.0

            item = self.catalog.barcode_item_map.get(barcode)
            if not item:
                return 0.0

            # Calculate overdue financial liability
            fine_incurred = self.fine_strategy.calculate_fine(loan, return_date)
            if fine_incurred > 0:
                member.apply_fine(fine_incurred)
                print(f"[Fine Warning] Item overdue! {member.name} assessed fine of ${fine_incurred:.2f}")

            # Check reservation hold queues for this ISBN
            isbn = item.isbn
            waiting_queue = self.reservations.get(isbn, [])
            has_queue = len(waiting_queue) > 0
            
            item.mark_returned(has_pending_reservations=has_queue)
            member.active_loan_count -= 1

            if has_queue:
                next_in_line_member_id = waiting_queue.pop(0)
                print(f"[Reservation Alert] Barcode {barcode} tagged as RESERVED on hold for waiting Patron ID: {next_in_line_member_id}")
            else:
                print(f"[Check-in Complete] Barcode {barcode} returned to circulation rack: {item.rack}")

            return fine_incurred

    def reserve_book(self, member: Member, isbn: str):
        with self.lock:
            self.reservations.setdefault(isbn, []).append(member.account_id)
            position = len(self.reservations[isbn])
            print(f"[Reservation Concluded] Patron {member.name} placed on hold queue for ISBN {isbn} at position #{position}.")


# --- Verification Simulation Engine ---
if __name__ == "__main__":
    # Bootstrap system objects and pricing engines
    catalog = CatalogIndex()
    fine_engine = FineCalculationStrategy(daily_rate=0.75, grace_days=1, max_fine_cap=15.0)
    library_system = LibraryService(catalog, fine_engine)

    # Populate inventory assets
    clean_code = Book("978-0132350884", "Clean Code: A Handbook of Agile Software Craftsmanship", "Robert C. Martin", "Engineering")
    catalog.register_book(clean_code)

    copy_1 = BookItem("BC-00101", "978-0132350884", Rack(aisle=4, shelf="B", position=12))
    clean_code.add_item(copy_1)
    catalog.register_item_barcode(copy_1)

    # Initialize patron membership profiles
    sarthak = Member("MEM-01", "Sarthak Srivastava")
    alice = Member("MEM-02", "Alice Vance")

    print("\n--- Phase 1: Standard Checkout Operations ---")
    loan = library_system.checkout_item(sarthak, "978-0132350884")

    print("\n--- Phase 2: Stock Exhaustion & Reservation Queues ---")
    # Alice attempts to borrow identical title whose sole copy is already active with Sarthak
    library_system.checkout_item(alice, "978-0132350884")
    library_system.reserve_book(alice, "978-0132350884")

    print("\n--- Phase 3: Overdue Check-in & Automatic Hold Notification ---")
    # Simulate Sarthak returning book 10 days late (Overdue return!)
    late_return_timestamp = datetime.now() + timedelta(days=24) # Due date was 14 days
    library_system.return_item(sarthak, "BC-00101", late_return_timestamp)

    print("\n--- Phase 4: Account Delinquency Lock Verification ---")
    # Try borrowing another book while carrying unpaid balance above delinquency limits
    print(f"Sarthak Account Profile -> Status: {sarthak.status.name}, Unpaid Fines: ${sarthak.unpaid_fines:.2f}")
    library_system.checkout_item(sarthak, "978-0132350884")