siftlode/backend/app/routes/plex/people.py

"""Plex people: cast/crew filter-chip cards + a single person's filmography page."""

import threading
import time

from fastapi import APIRouter, BackgroundTasks, Depends
from sqlalchemy import func, or_, select
from sqlalchemy.orm import Session

from app.collation import collated
from app import logs, sysconfig
from app.auth import current_user
from app.db import SessionLocal, get_db
from app.models import (
    PlexItem,
    PlexPerson,
    PlexShow,
    User,
)
from app.plex import rollup
from app.plex import tmdb as plex_tmdb
from app.plex.cards import movie_card, norm_lang, show_card
from app.plex.query import content_libs, split_csv, title_col

router = APIRouter(prefix="/api/plex", tags=["plex"])
log = logs.get_logger(__name__)


# How many "Known for" titles the person page shows (the stored pool is deeper; see plex.tmdb).
_KNOWN_FOR_SHOWN = 15


def _resolve_known_for(
    db: Session,
    known_for: list | None,
    uid: int,
    movie_lib_ids: list[int],
    show_lib_ids: list[int],
    lang: str,
) -> list[dict]:
    """The person's TMDB "Known for" credits (most-voted first) that are IN our library, as cards, in
    that order, at most _KNOWN_FOR_SHOWN. Matched by the canonical guid `tmdb:<id>`; out-of-library
    credits are dropped."""
    if not known_for:
        return []
    # Match each credit to a library row by guid, bucketed by media_type (movie ids and tv ids collide
    # numerically) and scoped to the enabled libraries — the shared helper owns that collision-safe
    # logic (the detail-page recs use the same one).
    movies, shows = plex_tmdb.resolve_library_guids(
        db, known_for, movie_lib_ids=movie_lib_ids, show_lib_ids=show_lib_ids
    )
    m_states = rollup.item_state_map(db, uid, [m.id for m in movies.values()])
    show_statuses = rollup.state_map(db, uid, [s.id for s in shows.values()])
    out: list[dict] = []
    for k in known_for:
        g = f"tmdb:{k.get('tmdb_id')}"
        # A credit resolves against its OWN media_type's bucket only.
        if k.get("media_type") == "tv":
            if g in shows:
                out.append(show_card(shows[g], show_statuses.get(shows[g].id, "new"), lang=lang))
        elif g in movies:
            out.append(movie_card(movies[g], m_states.get(movies[g].id), lang=lang))
    return out[:_KNOWN_FOR_SHOWN]


@router.get("/people/cards")
def people_cards(
    names: str,
    scope: str = "both",
    user: User = Depends(current_user),
    db: Session = Depends(get_db),
) -> dict:
    """Cards for the actor filter-chips currently applied: each name + its cached headshot + how many
    movies/shows (in the given scope) feature them. Photos come from the plex_people cache (populated
    as items are rich-fetched — info-page view + the rich re-sync); counts are live against cast_names.
    A name with no cached photo yet still returns a card (the UI shows a placeholder)."""
    wanted = split_csv(names)[:16]
    if not wanted:
        return {"people": []}
    movie_lib_ids, show_lib_ids = content_libs(db)
    want_movies = scope in ("movie", "both") and bool(movie_lib_ids)
    want_shows = scope in ("show", "both") and bool(show_lib_ids)
    photos = {
        p.name: p.photo_thumb
        for p in db.execute(select(PlexPerson).where(PlexPerson.name.in_(wanted))).scalars()
    }
    out = []
    for nm in wanted:
        count = 0
        if want_movies:
            count += (
                db.scalar(
                    select(func.count(PlexItem.id)).where(
                        PlexItem.kind == "movie",
                        PlexItem.library_id.in_(movie_lib_ids),
                        PlexItem.cast_names.contains([nm]),
                    )
                )
                or 0
            )
        if want_shows:
            count += (
                db.scalar(
                    select(func.count(PlexShow.id)).where(
                        PlexShow.library_id.in_(show_lib_ids),
                        PlexShow.cast_names.contains([nm]),
                    )
                )
                or 0
            )
        out.append({"name": nm, "photo": photos.get(nm), "count": count})
    return {"people": out}


# Cap each filmography section — a prolific person shouldn't return an unbounded list the client then
# mounts a card per row for (the grid paginates at PAGE; this page renders all at once). Ample for a
# personal library; the most-recent titles win via the year-desc order.
_PERSON_SECTION_MAX = 200


# A person's bio is enriched at most once per this window: it dedups concurrent opens of the same person
# (each would otherwise schedule its own 8s TMDB task) AND rate-limits re-triggering when TMDB is
# down/slow (a transient failure leaves tmdb_enriched_at NULL, so without this every reload would spawn a
# fresh task and pile up on the shared threadpool). In-process + best-effort: a restart just clears it, at
# worst costing a few extra fetches. A successful enrich stamps the watermark, so the reservation only
# ever expires harmlessly.
_ENRICH_COOLDOWN_S = 60.0
_enrich_inflight: dict[int, float] = {}
_enrich_lock = threading.Lock()


def _should_schedule_enrich(person_id: int) -> bool:
    """True (and reserves a cooldown) if this person isn't already being enriched / recently attempted."""
    now = time.monotonic()
    with _enrich_lock:
        deadline = _enrich_inflight.get(person_id)
        if deadline is not None and now < deadline:
            return False
        _enrich_inflight[person_id] = now + _ENRICH_COOLDOWN_S
        # Bound the map: drop expired reservations once it grows (a large library has many people).
        if len(_enrich_inflight) > 1024:
            for pid in [p for p, d in _enrich_inflight.items() if d <= now]:
                del _enrich_inflight[pid]
        return True


def _enrich_person_bg(person_id: int) -> None:
    """Fetch + persist one person's TMDB bio OFF the request path — a FastAPI background task that runs
    AFTER the response is sent, so the outbound TMDB call never sits on the serve latency (the module's
    "no live TMDB call at serve time" invariant). The request's session is already closed by then, so
    open a fresh one. Best-effort: a TMDB failure just leaves `tmdb_enriched_at` NULL to retry on the
    next open, and the bio lands from the row by then."""
    db = SessionLocal()
    try:
        person = db.get(PlexPerson, person_id)
        if person is not None:
            plex_tmdb.enrich_person(db, person)
    except Exception:  # noqa: BLE001 — background best-effort; never surfaces to a user
        db.rollback()
        log.warning("background person bio enrich failed for id=%s", person_id, exc_info=True)
    finally:
        db.close()


@router.get("/person/{name}")
def person_detail(
    name: str,
    background_tasks: BackgroundTasks,
    lang: str = "en",
    user: User = Depends(current_user),
    db: Session = Depends(get_db),
) -> dict:
    """One cast/crew member's filmography: their cached headshot + the movies and shows (in the enabled
    libraries) whose cast OR directors include this name — the inverse of the cast-name → library-filter
    link. The name string is the identity key (Plex cast carries no stable per-person id), so distinct
    people who share a name share a page. Each section is capped at _PERSON_SECTION_MAX. An unknown name
    simply returns empty sections.

    The first time a page is opened, the person's TMDB bio + "Known for" credits are lazily
    fetched (from the linked `tmdb_person_id`) and persisted, then served from the row on every open.
    The fetch runs OFF the request path (a background task); the first open serves whatever's in the row
    with `enriching` set, and the page asks again until the bio lands. The people_enrich job
    fetches everyone ahead of time, so this lazy path is only for a person the job hasn't reached yet.
    """
    lang = norm_lang(lang)
    person = db.execute(select(PlexPerson).where(PlexPerson.name == name)).scalars().first()
    # Lazy one-time bio enrich, scheduled AFTER the response so the TMDB call is never on the serve path.
    # Gated by a per-person cooldown so concurrent/rapid opens (or repeated opens while TMDB is degraded)
    # can't pile background tasks onto the shared threadpool.
    # `enriching` tells the page the bio is on its way: it asks again shortly instead of showing
    # an empty page until the next open. True while a fetch is pending, including one an earlier open
    # already reserved.
    enriching = (
        person is not None
        and bool(person.tmdb_person_id)
        and person.tmdb_enriched_at is None
        and bool(sysconfig.get_str(db, "tmdb_api_key"))
    )
    if enriching and person is not None and _should_schedule_enrich(person.id):
        background_tasks.add_task(_enrich_person_bg, person.id)
    movie_lib_ids, show_lib_ids = content_libs(db)

    movies: list[dict] = []
    if movie_lib_ids:
        items = (
            db.execute(
                select(PlexItem)
                .where(
                    PlexItem.kind == "movie",
                    PlexItem.library_id.in_(movie_lib_ids),
                    or_(
                        PlexItem.cast_names.contains([name]),
                        PlexItem.directors.contains([name]),
                    ),
                )
                .order_by(
                    PlexItem.year.desc().nullslast(), collated(title_col(PlexItem, lang), lang)
                )
                .limit(_PERSON_SECTION_MAX)
            )
            .scalars()
            .all()
        )
        states = rollup.item_state_map(db, user.id, [it.id for it in items])
        movies = [movie_card(it, states.get(it.id), lang=lang) for it in items]

    shows: list[dict] = []
    if show_lib_ids:
        show_rows = (
            db.execute(
                select(PlexShow)
                .where(
                    PlexShow.library_id.in_(show_lib_ids),
                    or_(
                        PlexShow.cast_names.contains([name]),
                        PlexShow.directors.contains([name]),
                    ),
                )
                .order_by(
                    PlexShow.year.desc().nullslast(), collated(title_col(PlexShow, lang), lang)
                )
                .limit(_PERSON_SECTION_MAX)
            )
            .scalars()
            .all()
        )
        statuses = rollup.state_map(db, user.id, [s.id for s in show_rows])
        shows = [show_card(sh, statuses.get(sh.id, "new"), lang=lang) for sh in show_rows]

    known_for = _resolve_known_for(
        db, person.known_for if person else None, user.id, movie_lib_ids, show_lib_ids, lang
    )
    return {
        "name": name,
        "photo": person.photo_thumb if person else None,
        # The Hungarian biography for a Hungarian reader, the instance-language one when TMDB has none.
        "biography": ((person.biography_hu if lang == "hu" else None) or person.biography)
        if person
        else None,
        "birthday": person.birthday if person else None,
        "deathday": person.deathday if person else None,
        "place_of_birth": person.place_of_birth if person else None,
        "known_for_department": person.known_for_department if person else None,
        "also_known_as": (person.also_known_as if person else None) or [],
        "known_for": known_for,
        "enriching": enriching,
        "movies": movies,
        "shows": shows,
    }