"""Geboundeter Domain-Crawler für Link-Quellen — rendert JS via Playwright (Chromium).

Lädt ab einer Start-URL Seiten + PDFs — NUR dieselbe Domain, begrenzte Tiefe und
Seitenzahl. HTML-Seiten werden im Headless-Browser gerendert (für SPAs nötig), dann
Links + Text aus dem fertigen DOM gezogen. PDFs werden direkt als Bytes geladen.
Deterministisch, gebounded; läuft via asyncio.to_thread (Sync-API, kein Event-Loop).
"""

import hashlib
import logging
import re
from pathlib import Path
from urllib.parse import urldefrag, urlparse
from urllib.request import Request, urlopen

from fsutil import atomic_write_text

log = logging.getLogger("creator.crawl")

MAX_TIEFE = 3
MAX_SEITEN = 500
SEITE_TIMEOUT = 30        # Sekunden pro Seite (Render bzw. PDF-Download)
CRAWL_SETTLE_MS = 3000    # gedeckelter Settle nach domcontentloaded (SPA-Render); kein 30s-networkidle-Hang
MAX_BYTES = 10_000_000    # 10 MB Deckel pro PDF
_UA = "Mozilla/5.0 (creator-lernbot)"


def _fetch_bytes(url: str) -> bytes | None:
    """PDF-Bytes per urllib laden (kein Rendering nötig). None bei Fehler/zu groß."""
    try:
        req = Request(url, headers={"User-Agent": _UA})
        with urlopen(req, timeout=SEITE_TIMEOUT) as resp:
            data = resp.read(MAX_BYTES + 1)
        return None if len(data) > MAX_BYTES else data
    except Exception as e:
        log.debug("crawl: PDF-Fetch fehlgeschlagen %s: %s", url, e)
        return None


def _name(url: str, ext: str) -> str:
    h = hashlib.md5(url.encode("utf-8")).hexdigest()[:8]
    slug = re.sub(r"[^a-zA-Z0-9]+", "-", urlparse(url).path).strip("-")[:60] or "index"
    return f"{h}-{slug}{ext}"


def _is_pdf(url: str) -> bool:
    return url.lower().split("?")[0].rstrip("/").endswith(".pdf")


def _scope_prefix(start_url: str) -> str:
    """Erstes nicht-leeres Pfad-Segment der Start-URL als Crawl-Scope, z.B.
    `/learn/path/x` → `/learn`. Ohne Pfad-Segment → `""` (ganze Domain, kein Regress)."""
    seg = [s for s in urlparse(start_url).path.split("/") if s]
    return f"/{seg[0]}" if seg else ""


def _in_scope(url: str, prefix: str) -> bool:
    """Segment-genauer Prefix-Match (kein `/learn` ⊃ `/learning-x`). Leerer Prefix → alles erlaubt."""
    if not prefix:
        return True
    p = urlparse(url).path
    return p == prefix or p.startswith(prefix + "/")


def _seiten_text(page) -> str:
    """Haupttext der gerenderten Seite — Nav/Footer/Boilerplate per trafilatura entfernt.
    Fallback auf den rohen Body-Text, wenn die Extraktion leer/zu kurz ausfällt (Nicht-Artikel-Seiten)."""
    try:
        from trafilatura import extract  # lazy: Backend startet auch ohne das Paket
        text = extract(page.content(), include_comments=False, include_tables=True) or ""
    except Exception:
        text = ""
    if len(text.strip()) >= 200:
        return text.strip()
    try:
        return page.inner_text("body").strip()
    except Exception:
        return text.strip()


def crawl(start_url: str, ziel: Path, *, max_tiefe: int = MAX_TIEFE, max_seiten: int = MAX_SEITEN, cancelled=None) -> int:
    """Crawlt ab start_url (nur gleiche Domain), rendert JS und legt Seiten/PDFs in `ziel` ab.

    BFS bis `max_tiefe` / `max_seiten`. Fehler einzelner Seiten werden übersprungen.
    Schreibt am ENDE einen `.done`-Marker; ein Abbruch (`cancelled()` → True) lässt ihn weg,
    sodass ein Neustart neu crawlt. Gibt die Zahl gespeicherter Quellen zurück.
    """
    # Lazy: so startet das Backend auch ohne installiertes Playwright; nur das Crawlen schlägt dann fehl.
    from playwright.sync_api import sync_playwright

    ziel.mkdir(parents=True, exist_ok=True)
    domain = urlparse(start_url).netloc
    prefix = _scope_prefix(start_url)  # nur Links unter diesem Pfad-Segment folgen
    gesehen: set[str] = set()
    queue: list[tuple[str, int]] = [(urldefrag(start_url)[0], 0)]
    gespeichert = 0

    with sync_playwright() as pw:
        browser = pw.chromium.launch(args=["--no-sandbox"])  # non-root (Docker user app)
        page = browser.new_page(user_agent=_UA)
        try:
            while queue and gespeichert < max_seiten:
                if cancelled and cancelled():
                    return gespeichert  # Abbruch → KEIN .done-Marker → Neustart crawlt neu
                url, tiefe = queue.pop(0)
                if url in gesehen:
                    continue
                gesehen.add(url)

                # PDFs brauchen kein Rendering — direkt laden.
                if _is_pdf(url):
                    data = _fetch_bytes(url)
                    if data:
                        p = ziel / _name(url, ".pdf")
                        if not p.exists():
                            p.write_bytes(data)
                        gespeichert += 1
                    continue

                try:
                    page.goto(url, wait_until="domcontentloaded", timeout=SEITE_TIMEOUT * 1000)
                except Exception as e:
                    log.debug("crawl: goto unvollständig %s: %s", url, e)  # trotzdem versuchen, Inhalt zu lesen
                try:
                    page.wait_for_load_state("networkidle", timeout=CRAWL_SETTLE_MS)
                except Exception:
                    pass  # SPA mit Dauer-Traffic erreicht nie idle → nach Settle weiter, kein 30s-Hang
                text = _seiten_text(page)  # Haupttext, Nav/Footer entfernt (Fallback: roher Body)
                if text:
                    atomic_write_text(ziel / _name(url, ".txt"), f"QUELLE: {url}\n\n{text}")
                    gespeichert += 1
                if tiefe < max_tiefe:
                    try:
                        hrefs = page.eval_on_selector_all("a[href]", "els => els.map(e => e.href)")
                    except Exception:
                        hrefs = []
                    for href in hrefs:
                        nxt = urldefrag(href)[0]
                        if (nxt.startswith(("http://", "https://"))
                                and urlparse(nxt).netloc == domain and _in_scope(nxt, prefix)
                                and nxt not in gesehen):
                            queue.append((nxt, tiefe + 1))
        finally:
            browser.close()

    (ziel / ".done").write_text("ok", encoding="utf-8")  # sauber durchgelaufen
    log.info("crawl %s → %d Quellen in %s", start_url, gespeichert, ziel)
    return gespeichert