api.py

"""
FastAPI REST API for the Library Management System.

Provides endpoints for CRUD operations on books and integration
with the OpenLibrary API for fetching book metadata.
"""

import logging
from contextlib import asynccontextmanager
from typing import List, Optional

from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel, field_validator

import config
from library import Library, Book as LibraryBook
from main import get_book_details_from_openlibrary
from validators import validate_isbn, validate_year, ValidationError

# Configure logging
logging.basicConfig(
    level=getattr(logging, config.LOG_LEVEL.upper(), logging.INFO),
    format=config.LOG_FORMAT,
    handlers=[
        logging.StreamHandler(),
        *([logging.FileHandler(config.LOG_FILE)] if config.LOG_FILE else [])
    ]
)
logger = logging.getLogger(__name__)


# This dictionary will hold our single Library instance.
app_state = {}


@asynccontextmanager
async def lifespan(app: FastAPI):
    """Manage application lifecycle - startup and shutdown."""
    logger.info("Server starting up...")
    # Create the single, shared Library instance and store it in the app_state.
    app_state["library"] = Library(config.LIBRARY_FILE)
    logger.info(f"Library loaded with {len(app_state['library'].books)} books.")
    yield
    # This code runs when the application is shutting down.
    logger.info("Server shutting down...")
    app_state["library"].save_books()
    logger.info("Library data saved.")


app = FastAPI(
    title="Library API",
    description="A simple API to manage a library of books.",
    version="1.0.0",
    lifespan=lifespan
)

# Add CORS middleware with configurable origins
app.add_middleware(
    CORSMiddleware,
    allow_origins=config.CORS_ORIGINS,
    allow_credentials=config.CORS_ALLOW_CREDENTIALS,
    allow_methods=config.CORS_ALLOW_METHODS,
    allow_headers=config.CORS_ALLOW_HEADERS,
)

logger.info(f"CORS configured with origins: {config.CORS_ORIGINS}")


class Book(BaseModel):
    """Pydantic model for a book, used for API request and response validation."""
    title: str
    author: str
    isbn: str
    year: int
    available: bool = True
    date_added: Optional[str] = None

    @field_validator('isbn')
    @classmethod
    def validate_isbn_format(cls, v: str) -> str:
        """Validate ISBN format (ISBN-10 or ISBN-13)."""
        try:
            validate_isbn(v)
        except ValidationError as e:
            raise ValueError(str(e))
        return v

    @field_validator('year')
    @classmethod
    def validate_year_range(cls, v: int) -> int:
        """Validate publication year is within reasonable range."""
        try:
            validate_year(v)
        except ValidationError as e:
            raise ValueError(str(e))
        return v

    @field_validator('title', 'author')
    @classmethod
    def validate_not_empty(cls, v: str, info) -> str:
        """Validate that title and author are not empty."""
        if not v or not v.strip():
            raise ValueError(f"{info.field_name} cannot be empty")
        return v.strip()


@app.get("/health")
async def health_check():
    """Health check endpoint for container orchestration."""
    return {
        "status": "healthy",
        "books_count": len(app_state.get("library", Library()).books)
    }


@app.get("/books", response_model=List[Book])
async def list_all_books():
    """Retrieve a list of all books in the library."""
    library = app_state["library"]
    logger.debug(f"Listing all {len(library.books)} books")
    return [book.to_dict() for book in library.books]


@app.get("/books/{isbn}", response_model=Book)
async def get_single_book(isbn: str):
    """Retrieve a single book by its ISBN."""
    library = app_state["library"]
    book = library.find_book(isbn)
    if book is None:
        logger.warning(f"Book not found: ISBN={isbn}")
        raise HTTPException(status_code=404, detail="Book not found")
    logger.debug(f"Retrieved book: {book.title} (ISBN={isbn})")
    return book.to_dict()


@app.get("/openlibrary/{isbn}")
async def fetch_openlibrary_info(isbn: str):
    """Fetch book details from OpenLibrary without adding to the library."""
    logger.info(f"Fetching book details from OpenLibrary: ISBN={isbn}")
    book_data = get_book_details_from_openlibrary(isbn)
    if not book_data:
        logger.warning(f"Book not found on OpenLibrary: ISBN={isbn}")
        raise HTTPException(status_code=404, detail="Book not found on OpenLibrary.")
    logger.info(f"Found book on OpenLibrary: {book_data.get('title', 'Unknown')}")
    return book_data


@app.post("/books", response_model=Book, status_code=201)
async def add_new_book(book: Book):
    """Add a new book to the library."""
    library = app_state["library"]
    if any(b.isbn == book.isbn for b in library.books):
        logger.warning(f"Attempted to add duplicate book: ISBN={book.isbn}")
        raise HTTPException(status_code=400, detail="Book with this ISBN already exists")

    new_book = LibraryBook(**book.model_dump(exclude_none=True))
    library.add_book(new_book)
    logger.info(f"Added new book: {book.title} (ISBN={book.isbn})")

    # Find the book again to get the version with the timestamp
    added_book = library.find_book(new_book.isbn)
    return added_book.to_dict()


@app.put("/books/{isbn}", response_model=Book)
async def update_existing_book(isbn: str, updated_book: Book):
    """Update an existing book's details."""
    library = app_state["library"]
    book_to_update = library.find_book(isbn)
    if book_to_update is None:
        logger.warning(f"Attempted to update non-existent book: ISBN={isbn}")
        raise HTTPException(status_code=404, detail="Book not found")

    update_data = updated_book.model_dump(exclude={'isbn'}, exclude_none=True)
    library.update_book(isbn, **update_data)
    logger.info(f"Updated book: ISBN={isbn}")

    updated_book_data = library.find_book(isbn)
    return updated_book_data.to_dict()


@app.delete("/books/{isbn}", status_code=204)
async def remove_existing_book(isbn: str):
    """Remove a book from the library."""
    library = app_state["library"]
    if not library.find_book(isbn):
        logger.warning(f"Attempted to remove non-existent book: ISBN={isbn}")
        raise HTTPException(status_code=404, detail="Book not found")

    library.remove_book(isbn)
    logger.info(f"Removed book: ISBN={isbn}")
    return {}