goon/app/connectors/tpdb.py

"""ThePornDB REST connector.

API: https://api.theporndb.net  (auth: Bearer token)
Lista scen: GET /scenes?per_page=200&page=N&date={YYYY-MM-DD}  (delta filter)
Format: {data: [...], meta: {current_page, last_page, per_page, total}}

Sceny TPDB zwracają już rozwiniętych performerów (`performers[]`), studio (`site`) i tagi (`tags[]`).
W związku z tym pojedyncze GET /scenes wystarcza do MVP — nie musimy uderzać oddzielnie po performera.

Format performera w scenie:
  - performer.id        — ID przypisania performer↔scene (NIE używać do dedup)
  - performer.name      — imię w tej konkretnej scenie (może być alias, np. „Mia M.")
  - performer.parent.id — kanoniczne UUID performerki w TPDB → external_id
  - performer.parent.name / .extra.gender / .extra.birthday — kanoniczne metadane

Format studia: scene.site = {id, name, slug, parent: {...}, network: {...}}
"""
from __future__ import annotations

import logging
from collections.abc import Iterator
from datetime import date, datetime
from typing import Any

import httpx
from tenacity import (
    retry,
    retry_if_exception,
    retry_if_exception_type,
    stop_after_attempt,
    wait_exponential,
)


def _is_retryable_http_error(exc: BaseException) -> bool:
    """Retry transport errors + 5xx + 429; NIE retry 4xx (404/422 = permanent).

    401/403 NIE są retryowalne tutaj — TPDB token expiry musiałby być
    obsłużony jako auth refresh (TODO gdyby zaczęły się pojawiać). Aktualnie
    expire'a się raz na rok, więc nie warto kombinować.
    """
    if isinstance(exc, httpx.TransportError):
        return True
    if isinstance(exc, httpx.HTTPStatusError):
        sc = exc.response.status_code
        return sc == 429 or sc >= 500
    return False

from app.config import get_settings
from app.connectors.base import (
    BaseConnector,
    RawMovie,
    RawPerformer,
    RawScene,
    RawStudio,
    RawTag,
)
from app.models.source import SourceKind

log = logging.getLogger(__name__)


class TPDBConnector(BaseConnector):
    kind = SourceKind.tpdb
    name = "tpdb"

    def __init__(
        self,
        *,
        token: str | None = None,
        base_url: str | None = None,
        per_page: int = 100,
        timeout: float = 30.0,
    ) -> None:
        settings = get_settings()
        self.token = token or settings.tpdb_api_token
        if not self.token:
            raise RuntimeError("TPDB_API_TOKEN is not set")
        self.base_url = (base_url or settings.tpdb_base_url).rstrip("/")
        self.per_page = per_page
        self.timeout = timeout

    def _client(self) -> httpx.Client:
        return httpx.Client(
            base_url=self.base_url,
            headers={
                "Authorization": f"Bearer {self.token}",
                "Accept": "application/json",
                "User-Agent": "goon/0.1",
            },
            timeout=self.timeout,
        )

    @retry(
        retry=retry_if_exception(_is_retryable_http_error),
        wait=wait_exponential(multiplier=1, min=2, max=30),
        stop=stop_after_attempt(5),
        reraise=True,
    )
    def _get(self, client: httpx.Client, path: str, params: dict[str, Any]) -> dict[str, Any]:
        resp = client.get(path, params=params)
        if resp.status_code == 429:
            # let tenacity retry — but raise something it knows
            raise httpx.HTTPStatusError("rate limited", request=resp.request, response=resp)
        resp.raise_for_status()
        return resp.json()

    def fetch_scenes(
        self,
        *,
        since: datetime | None = None,
        limit: int | None = None,
    ) -> Iterator[RawScene]:
        params: dict[str, Any] = {"per_page": self.per_page}
        if since is not None:
            params["date"] = since.date().isoformat()

        yield from self._paginate_scenes(params, limit=limit)

    def fetch_scenes_for_performer(
        self,
        performer_external_id: str,
        *,
        limit: int | None = None,
    ) -> Iterator[RawScene]:
        """Pobiera wszystkie sceny TPDB dla performera o podanym kanonicznym ID.

        TPDB API: GET /performers/<id>/scenes — dedykowany endpoint.
        (Inne warianty są broken: /scenes?performers[]=<uuid> zwraca zawsze total=0,
        /scenes?performer_id=<uuid> → 422.)

        404 = performer usunięty z TPDB (np. b959ccbb 2026-05-16 Sentry GOON-N).
        Wcześniej leciało raise → exception bąbelek do scheduler.performer_driven
        → cały run failed. Teraz warn + yield empty — caller widzi 0 scen i
        kontynuuje z następnym performer.
        """
        try:
            yield from self._paginate_scenes(
                {"per_page": self.per_page},
                limit=limit,
                path=f"/performers/{performer_external_id}/scenes",
            )
        except httpx.HTTPStatusError as e:
            if e.response.status_code == 404:
                log.warning(
                    "tpdb performer %s removed (404) — skipping",
                    performer_external_id,
                )
                return
            raise

    def fetch_scenes_for_site(
        self,
        site_external_id: str,
        *,
        limit: int | None = None,
    ) -> Iterator[RawScene]:
        """Pobiera wszystkie sceny TPDB dla site/studio o podanym ID.

        TPDB API: GET /sites/<id>/scenes — dedykowany endpoint analogiczny
        do /performers/<id>/scenes. Bez paginacji limit zwraca total scenes
        z meta.total (Brazzers=272, Naughty America=631 w czasie pisania).

        404 = site usunięty z TPDB — analogicznie do fetch_scenes_for_performer.
        """
        try:
            yield from self._paginate_scenes(
                {"per_page": self.per_page},
                limit=limit,
                path=f"/sites/{site_external_id}/scenes",
            )
        except httpx.HTTPStatusError as e:
            if e.response.status_code == 404:
                log.warning(
                    "tpdb site %s removed (404) — skipping",
                    site_external_id,
                )
                return
            raise

    def find_performer_id_by_name(self, name: str) -> str | None:
        """GET /performers?q=<name> → pierwszy match. None gdy brak."""
        with self._client() as client:
            try:
                payload = self._get(client, "/performers", {"q": name, "per_page": 5})
            except httpx.HTTPStatusError as e:
                log.warning("tpdb /performers q=%s failed: %s", name, e)
                return None
        data = payload.get("data") or []
        if not data:
            return None
        for item in data:
            # exact (case-insensitive) match preferowany; fallback do pierwszego
            if (item.get("name") or "").strip().lower() == name.strip().lower():
                return str(item.get("id")) if item.get("id") else None
        first = data[0]
        return str(first.get("id")) if first.get("id") else None

    def search_movies(self, query: str, *, per_page: int = 10) -> list[dict[str, Any]]:
        """GET /movies?q=<query> → surowe payloady filmów (list endpoint jest już
        hydrated: tags + performers + site embedded, bez detail-fetcha).

        Używane do enrichmentu movies: wyszukujemy kandydatów po tytule, scorujemy
        i mapujemy najlepszy przez `_parse_movie`. Pusty list na błąd/brak."""
        if not query.strip():
            return []
        with self._client() as client:
            try:
                payload = self._get(client, "/movies", {"q": query, "per_page": per_page})
            except httpx.HTTPStatusError as e:
                log.warning("tpdb /movies q=%s failed: %s", query, e)
                return []
        return payload.get("data") or []

    def fetch_movie(self, movie_uuid: str) -> dict[str, Any] | None:
        """GET /movies/<uuid> → pojedynczy film (detail). None gdy 404/błąd.

        NB: list endpoint jest już hydrated, więc detail rzadko potrzebny — trzymamy
        dla spójności / gdyby TPDB kiedyś przeniósł część pól tylko do detalu."""
        with self._client() as client:
            try:
                payload = self._get(client, f"/movies/{movie_uuid}", {})
            except httpx.HTTPStatusError as e:
                if e.response.status_code == 404:
                    return None
                log.warning("tpdb /movies/%s failed: %s", movie_uuid, e)
                return None
        return payload.get("data")

    def _paginate_scenes(
        self,
        params: dict[str, Any],
        *,
        limit: int | None,
        path: str = "/scenes",
    ) -> Iterator[RawScene]:
        emitted = 0
        page = 1
        with self._client() as client:
            while True:
                params["page"] = page
                payload = self._get(client, path, params)
                data = payload.get("data") or []
                if not data:
                    return
                for raw in data:
                    scene = _parse_scene(raw)
                    if scene is None:
                        continue
                    yield scene
                    emitted += 1
                    if limit is not None and emitted >= limit:
                        return

                meta = payload.get("meta") or {}
                last_page = meta.get("last_page") or page
                if page >= last_page:
                    return
                page += 1


def _parse_date(value: Any) -> date | None:
    if not value:
        return None
    if isinstance(value, date):
        return value
    text = str(value).strip()
    if not text:
        return None
    # TPDB dates: "YYYY-MM-DD" lub ISO datetime
    try:
        return date.fromisoformat(text[:10])
    except ValueError:
        return None


def _parse_studio(raw: dict[str, Any] | None) -> RawStudio | None:
    if not raw:
        return None
    parent = raw.get("parent") or {}
    network = raw.get("network") or {}
    return RawStudio(
        external_id=str(raw["id"]) if raw.get("id") is not None else None,
        name=raw.get("name") or "Unknown",
        slug=raw.get("short_name") or raw.get("slug"),
        parent_external_id=str(parent["id"]) if parent.get("id") is not None else None,
        parent_name=parent.get("name"),
        network=network.get("name") if isinstance(network, dict) else None,
        homepage_url=raw.get("url") or raw.get("home"),
    )


def _parse_performer(raw: dict[str, Any]) -> RawPerformer | None:
    parent = raw.get("parent") or {}
    extra = parent.get("extras") or parent.get("extra") or {}
    canonical_id = parent.get("id") or raw.get("id")
    canonical_name = parent.get("name") or raw.get("name")
    if not canonical_name:
        return None
    aliases_field = parent.get("aliases") or extra.get("aliases") or []
    if isinstance(aliases_field, str):
        aliases = [a.strip() for a in aliases_field.split(",") if a.strip()]
    else:
        aliases = [a for a in aliases_field if isinstance(a, str)]
    return RawPerformer(
        external_id=str(canonical_id) if canonical_id is not None else None,
        name=canonical_name,
        aliases=aliases,
        gender=(extra.get("gender") or parent.get("gender") or "").lower() or None,
        birth_date=_parse_date(extra.get("birthday")),
        country=extra.get("birthplace") or extra.get("country"),
        as_alias_in_scene=raw.get("name") if raw.get("name") != canonical_name else None,
    )


def _parse_tag(raw: dict[str, Any]) -> RawTag | None:
    name = raw.get("name")
    if not name:
        return None
    return RawTag(
        external_id=str(raw["id"]) if raw.get("id") is not None else None,
        name=name,
        slug=raw.get("slug"),
    )


def _parse_scene(raw: dict[str, Any]) -> RawScene | None:
    external_id = raw.get("id")
    title = raw.get("title")
    if not external_id or not title:
        log.warning("tpdb scene without id/title — skipping (keys=%s)", list(raw)[:8])
        return None

    performers: list[RawPerformer] = []
    for p in raw.get("performers") or []:
        parsed = _parse_performer(p)
        if parsed is not None:
            performers.append(parsed)

    tags: list[RawTag] = []
    for t in raw.get("tags") or []:
        parsed_t = _parse_tag(t)
        if parsed_t is not None:
            tags.append(parsed_t)


    return RawScene(
        external_id=str(external_id),
        title=title,
        description=raw.get("description"),
        release_date=_parse_date(raw.get("date")),
        duration_sec=int(raw["duration"]) if raw.get("duration") else None,
        code=raw.get("external_id"),
        director=raw.get("director"),
        url=raw.get("url"),
        studio=_parse_studio(raw.get("site")),
        performers=performers,
        tags=tags,
        fingerprints=[],  # TPDB nie publikuje pHashy w głównym endpoint
        raw=raw,
    )


def _parse_movie(raw: dict[str, Any]) -> RawMovie | None:
    """TPDB movie payload → RawMovie. Reużywa _parse_studio/_parse_performer/_parse_tag
    (movies mają identyczny kształt site/performers/tags co sceny)."""
    external_id = raw.get("id")
    title = raw.get("title")
    if not external_id or not title:
        return None

    performers: list[RawPerformer] = []
    for p in raw.get("performers") or []:
        parsed = _parse_performer(p)
        if parsed is not None:
            performers.append(parsed)
    tags: list[RawTag] = []
    for t in raw.get("tags") or []:
        parsed_t = _parse_tag(t)
        if parsed_t is not None:
            tags.append(parsed_t)

    directors = raw.get("directors") or []
    director = ", ".join(d.get("name") for d in directors if isinstance(d, dict) and d.get("name")) or None

    d = _parse_date(raw.get("date"))
    # duration bywa 1s-placeholderem na movies — poniżej 60s traktujemy jak brak.
    dur = raw.get("duration")
    duration_sec = int(dur) if dur and int(dur) > 60 else None

    def _img(field: str) -> str | None:
        v = raw.get(field)
        if isinstance(v, str) and v:
            return v
        if isinstance(v, dict):
            return v.get("large") or v.get("full") or v.get("medium") or None
        return None

    poster = _img("poster") or _img("posters")
    backdrop = _img("background") or _img("backdrop")

    return RawMovie(
        external_id=str(external_id),
        title=title,
        description=raw.get("description"),
        release_year=d.year if d else None,
        release_date=d,
        duration_sec=duration_sec,
        director=director,
        rating=float(raw["rating"]) if raw.get("rating") not in (None, "") else None,
        poster_url=poster,
        backdrop_url=backdrop,
        url=raw.get("url"),
        studio=_parse_studio(raw.get("site")),
        performers=performers,
        tags=tags,
        raw=raw,
    )