legex/fulltext/render_full_text.py

"""Render judgment pages with a real browser and write ``full_text.jsonl``.

Some courts (Taiwan's ``judgment.judicial.gov.tw``, Hong Kong's
``legalref.judiciary.hk``) reject plain HTTP clients or hide the judgment
behind script/anti-bot checks, so the requests-based ``scrape_full_text`` only
captured error placeholders. This module drives headless Chromium via
Playwright, waits for the judgment container to appear, and extracts its text.

Output matches ``legex.scrape_full_text`` / ``data/<cc>/full_text.jsonl`` so the
inference step consumes it unchanged: one JSON object per line with a
filesystem-safe ``case_id`` slug and a ``full_text`` body prefixed with the
original ``case_id``/``link``.

Per-site content selectors live in ``CONTENT_SELECTORS``; unknown sites fall
back to the page ``body``. Rows whose extracted text is shorter than
``--min-chars`` are recorded with a ``RENDER_EMPTY`` marker and retried on the
next ``--resume`` run.

Usage:
    uv run legex-render-fulltext --country tw
    uv run legex-render-fulltext --country tw --limit 5 --headed
    uv run legex-render-fulltext --country hk --resume
"""

from __future__ import annotations

import argparse
import json
import logging
import sys
import time
from collections.abc import Callable
from pathlib import Path

from openpyxl import load_workbook

from legex.pdf_export.core import safe_slug
from legex.pdf_export.workbook import cell, header_map
from legex.fulltext.scrape_full_text import build_full_text, normalize_ws
from legex.utils import full_text_jsonl_path, goldenset_path, goldenset_sheet

log = logging.getLogger("legex.render_full_text")

# CSS selector for the element holding the judgment body, per country code.
CONTENT_SELECTORS: dict[str, str] = {
    "tw": "#jud",            # FJUD data.aspx judgment container
    "hk": "body",            # ju_body.jsp renders the whole judgment in <body>
}

_DEFAULT_SELECTOR = "body"


def _rewrite_hk(url: str) -> str:
    """Hong Kong links point at the frameset ``ju_frame.jsp``; the judgment
    itself lives in the inner ``ju_body.jsp`` frame, which loads on its own."""
    if "ju_frame.jsp" in url:
        return url.replace("ju_frame.jsp", "ju_body.jsp") + "&AH=&QS=&FN=&currpage=T"
    return url


# Per-country link rewrites applied before navigation.
URL_REWRITES: dict[str, Callable[[str], str]] = {
    "hk": _rewrite_hk,
}

# Marker stored for rows that rendered but yielded no usable text, so a
# --resume run re-attempts them instead of treating them as done.
_EMPTY_MARKER = "RENDER_EMPTY"

_UA = (
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
    "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15"
)


def _load_done(out_path: Path) -> set[str]:
    """case_id slugs already present with real (non-empty) text."""
    done: set[str] = set()
    if not out_path.exists():
        return done
    with out_path.open(encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            try:
                rec = json.loads(line)
            except json.JSONDecodeError:
                continue
            cid = rec.get("case_id")
            body = rec.get("full_text", "")
            if cid and _EMPTY_MARKER not in body:
                done.add(cid)
    return done


def _extract_text(page, selector: str, min_chars: int) -> str:
    """Best non-empty text among the comma-separated selector candidates."""
    best = ""
    for sel in [s.strip() for s in selector.split(",") if s.strip()]:
        try:
            loc = page.locator(sel).first
            if loc.count() == 0:
                continue
            txt = loc.inner_text(timeout=5_000)
        except Exception:  # noqa: BLE001 - selector may be absent on a page
            continue
        txt = normalize_ws(txt or "")
        if len(txt) > len(best):
            best = txt
        if len(best) >= min_chars:
            break
    return best


def render_country(
    cc: str,
    out_path: Path,
    *,
    selector: str,
    pause_s: float,
    nav_timeout_ms: int,
    min_chars: int,
    limit: int | None,
    resume: bool,
    headed: bool,
) -> tuple[int, int]:
    """Render every link in the country's goldenset. Returns (written, empty)."""
    from playwright.sync_api import sync_playwright

    rewrite = URL_REWRITES.get(cc, lambda u: u)

    gs = goldenset_path(cc)
    wb = load_workbook(gs, read_only=True, data_only=True)
    ws = goldenset_sheet(wb)
    rows = ws.iter_rows(values_only=True)
    header = next(rows, None)
    if not header:
        wb.close()
        log.error("[%s] empty goldenset %s", cc, gs)
        return 0, 0
    h = header_map(header)
    idx_case = h.get("case_id")
    idx_link = h.get("link")
    idx_text = h.get("full_text")
    if idx_link is None:
        wb.close()
        log.error("[%s] no 'link' column in %s", cc, gs)
        return 0, 0

    done = _load_done(out_path) if resume else set()
    mode = "a" if (resume and out_path.exists()) else "w"
    out_path.parent.mkdir(parents=True, exist_ok=True)

    written = empty = 0
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=not headed)
        context = browser.new_context(user_agent=_UA, locale="zh-TW")
        page = context.new_page()
        page.set_default_navigation_timeout(nav_timeout_ms)

        with out_path.open(mode, encoding="utf-8") as out:
            row_idx = 1
            for row in rows:
                row_idx += 1
                if not row:
                    continue
                link = (cell(row, idx_link) or "").strip()
                case_id_raw = str(cell(row, idx_case) or "").strip()
                sheet_full = cell(row, idx_text) if idx_text is not None else None
                if not link and not case_id_raw:
                    continue
                slug = safe_slug(case_id_raw, link or None, row_idx)
                if slug in done:
                    continue
                if limit is not None and (written + empty) >= limit:
                    break

                body, source = "", "render"
                if link.startswith("http"):
                    nav_url = rewrite(link)
                    try:
                        page.goto(nav_url, wait_until="domcontentloaded")
                        try:
                            page.wait_for_selector(
                                selector.split(",")[0].strip(), timeout=nav_timeout_ms
                            )
                        except Exception:  # noqa: BLE001 - fall back to whatever loaded
                            pass
                        body = _extract_text(page, selector, min_chars)
                    except Exception as e:  # noqa: BLE001
                        log.warning("[%s] render failed row %d: %s", cc, row_idx, e)
                        body = ""

                if len(body) < min_chars:
                    empty += 1
                    sheet = normalize_ws(str(sheet_full)) if sheet_full else ""
                    if len(sheet) >= min_chars:
                        body, source = sheet, "full_text (Fallback)"
                    else:
                        body = f"{_EMPTY_MARKER} (rendered {len(body)} chars)"
                        source = "render (leer)"
                else:
                    written += 1

                full = build_full_text(case_id_raw, link, source, body)
                out.write(json.dumps({"case_id": slug, "full_text": full}, ensure_ascii=False))
                out.write("\n")
                out.flush()
                done.add(slug)
                if (written + empty) % 10 == 0:
                    log.info("[%s] %d ok / %d empty", cc, written, empty)
                time.sleep(pause_s)

        context.close()
        browser.close()
    wb.close()
    log.info("[%s] done: %d rendered, %d empty -> %s", cc, written, empty, out_path)
    return written, empty


def main(argv: list[str] | None = None) -> int:
    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
    ap = argparse.ArgumentParser(description="Render judgment pages with Playwright.")
    ap.add_argument("--country", required=True, help="Country code (resolves goldenset + output).")
    ap.add_argument("--out", type=Path, default=None, help="Output jsonl (default data/<cc>/full_text.jsonl).")
    ap.add_argument("--selector", default=None, help="Override the content CSS selector.")
    ap.add_argument("--pause", type=float, default=1.0, help="Seconds between page loads.")
    ap.add_argument("--nav-timeout", type=int, default=30_000, help="Navigation timeout (ms).")
    ap.add_argument("--min-chars", type=int, default=300, help="Below this a render counts as empty.")
    ap.add_argument("--limit", type=int, default=None, help="Max rows to render.")
    ap.add_argument("--resume", action="store_true", help="Skip rows already captured with text.")
    ap.add_argument("--headed", action="store_true", help="Show the browser window (debugging).")
    args = ap.parse_args(argv)

    cc = args.country
    gs = goldenset_path(cc)
    if not gs.exists():
        log.error("no goldenset for %s at %s", cc, gs)
        return 2

    out_path = args.out or full_text_jsonl_path(cc)
    selector = args.selector or CONTENT_SELECTORS.get(cc, _DEFAULT_SELECTOR)
    log.info("[%s] rendering with selector %r -> %s", cc, selector, out_path)

    written, empty = render_country(
        cc,
        out_path,
        selector=selector,
        pause_s=args.pause,
        nav_timeout_ms=args.nav_timeout,
        min_chars=args.min_chars,
        limit=args.limit,
        resume=args.resume,
        headed=args.headed,
    )
    return 0 if written else 1


if __name__ == "__main__":
    sys.exit(main())