#!/usr/bin/env python
"""Интерактивный сборщик датасета grabber-ai (rutracker / nnm-club / kinozal).

Запуск без аргументов открывает меню:

    .venv\\Scripts\\python tools\\collect.py

То же по командам (для скриптов):

    python tools/collect.py windows   [--sites rutracker,nnm,kinozal]
    python tools/collect.py collect   --site rutracker --refs 313,2366 --pages 3 --limit 100
    python tools/collect.py backfill  --site nnm --limit 200
    python tools/collect.py build
    python tools/collect.py import-legacy --dir <каталог старого harvest>
    python tools/collect.py status

Как это работает
----------------
* Chrome запускается ОДИН (общий профиль и cookie), по окну на трекер. Вы
  логинитесь в каждом окне сами; пароли и cookie скрипт не видит и не хранит.
  Профиль лежит вне репозитория: %LOCALAPPDATA%\\dub-ai-harvest\\chrome-profile
  (другой каталог: переменная DUB_CHROME_PROFILE).
* Каждая страница сохраняется ЦЕЛИКОМ (outerHTML после загрузки вкладок
  kinozal) в data/raw/<трекер>/<id>.html + <id>.json. Это тот же вход, который
  модель увидит в grabber, а не только текст поста.
* `build` превращает сырые страницы в data/pages/*.txt (через src.html_extract)
  и добавляет слабые метки в data/labels.csv (парсеры из tools/harvest).
* id страниц: у уже размеченных раздач остаётся прежний (bare) id, у новых —
  с префиксом (rt-123, nnm-123, kz-123): так id разных трекеров не пересекаются
  и разбиение train/test у старых страниц не меняется.
"""

from __future__ import annotations

import argparse
import csv
import json
import os
import random
import re
import sys
import threading
import time
from collections import Counter, deque
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
DATA = ROOT / "data"
RAW = DATA / "raw"
PAGES = DATA / "pages"
LABELS = DATA / "labels.csv"
POSTONLY = DATA / "pages_postonly.txt"
STATE = RAW / "_state.json"

_home = Path(os.environ.get("LOCALAPPDATA") or Path.home()) / "dub-ai-harvest"
os.environ.setdefault("DUB_HARVEST_OUT", str(_home))
os.environ.setdefault("DUB_CHROME_PROFILE", str(_home / "chrome-profile"))
# свой порт: не подключаться к чужому Chrome с отладкой на 9222 (окна открылись бы там)
os.environ.setdefault("DUB_CHROME_PORT", "9333")
sys.path.insert(0, str(ROOT))
sys.path.insert(0, str(ROOT / "tools"))
sys.path.insert(0, str(ROOT / "tools" / "harvest"))

import harvest_core as hv  # noqa: E402
import meta as metamod  # noqa: E402
import ui  # noqa: E402

META = DATA / "meta.csv"

DEFAULTS = {"tabs": 3, "delay": 1.0, "limit": 100, "pages": 2, "mode": "balanced", "per_page": 6, "workers": 0}


def clamp_tabs(value) -> int:
    try:
        return max(1, min(4, int(value)))
    except (TypeError, ValueError):
        return DEFAULTS["tabs"]


def settings() -> dict:
    """Настройки сбора (запоминаются между запусками): вкладок, пауза, лимит, страниц списка."""
    try:
        saved = json.loads((RAW / "_settings.json").read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        saved = {}
    cfg = {**DEFAULTS, **saved}
    cfg["tabs"] = clamp_tabs(cfg["tabs"])
    return cfg


def save_settings(cfg: dict) -> None:
    cfg = {**cfg, "tabs": clamp_tabs(cfg.get("tabs"))}
    RAW.mkdir(parents=True, exist_ok=True)
    (RAW / "_settings.json").write_text(json.dumps(cfg, ensure_ascii=False, indent=2), encoding="utf-8")
    os.environ["DUB_TABS"] = str(cfg["tabs"])

SITES = {
    "rutracker": {"prefix": "rt", "host": "rutracker.org",
                  "home": "https://rutracker.org/forum/index.php",
                  "refs": "313,2366", "what": "id разделов (viewforum.php?f=…)"},
    "nnm": {"prefix": "nnm", "host": "nnmclub.to",
            "home": "https://nnmclub.to/forum/index.php",
            "refs": "227,768", "what": "id разделов (viewforum.php?f=…)"},
    "kinozal": {"prefix": "kz", "host": "kinozal.me",
                "home": "https://kinozal.me/",
                "refs": "https://kinozal.me/browse.php",
                "what": "адреса списков (browse.php?… / top.php)"},
}

def say(msg: str = "", tag: str = "") -> None:
    from rich.markup import escape
    prefix = f"[{ui.SITE_STYLE.get(tag, 'dim')}]{tag}[/] " if tag else ""
    ui.console.print(prefix + escape(msg))


# ---------------------------------------------------------------- метки / id
def read_labels() -> list[dict]:
    if not LABELS.exists():
        return []
    with LABELS.open(encoding="utf-8-sig", newline="") as f:
        return list(csv.DictReader(f))


def migrate_labels() -> bool:
    """labels.csv со старой шапкой (без lang/audio_raw) -> новая шапка.

    cmd_build дописывает строки через DictWriter(FIELDS): под старой шапкой они сдвинули бы
    все колонки. Файл переписывается один раз, прежние данные не меняются; копия — labels.bak_schema.csv.
    """
    if not LABELS.exists() or LABELS.stat().st_size == 0:
        return False
    with LABELS.open(encoding="utf-8-sig", newline="") as f:
        reader = csv.DictReader(f)
        head, rows = reader.fieldnames or [], list(reader)
    if head == hv.FIELDS:
        return False
    import shutil
    bak = LABELS.with_name("labels.bak_schema.csv")
    if not bak.exists():
        shutil.copy2(LABELS, bak)
    with LABELS.open("w", encoding="utf-8-sig", newline="") as f:
        w = csv.DictWriter(f, fieldnames=hv.FIELDS, extrasaction="ignore", restval="")
        w.writeheader()
        w.writerows(rows)
    return True


def labeled_ids(rows: list[dict] | None = None) -> dict[str, set[str]]:
    """{источник: {release_id}} по текущему data/labels.csv."""
    out: dict[str, set[str]] = {s: set() for s in SITES}
    for r in rows if rows is not None else read_labels():
        out.setdefault(r["source"], set()).add(r["release_id"])
    return out


def page_stem(source: str, rid: str, labeled: dict[str, set[str]]) -> str:
    """Имя страницы = release_id в labels.csv.

    Размеченные раньше раздачи сохраняют свой bare id (их пары page/label и
    разбиение train/test не меняются), если этот id не занят другим
    источником. Все новые получают префикс источника.
    """
    if rid in labeled.get(source, ()):
        taken = any(rid in ids for s, ids in labeled.items() if s != source)
        if not taken:
            return rid
    return f"{SITES[source]['prefix']}-{rid}"


def real_id(site: str, release_id: str) -> str:
    """release_id из labels.csv -> id раздачи на трекере (без нашего префикса)."""
    pre = SITES[site]["prefix"] + "-"
    return release_id[len(pre):] if release_id.startswith(pre) else release_id


def labeled_real_ids(site: str, labeled: dict[str, set[str]] | None = None) -> set[str]:
    labeled = labeled if labeled is not None else labeled_ids()
    return {real_id(site, i) for i in labeled.get(site, ())}


def stored_ids(site: str) -> set[str]:
    d = RAW / site
    if not d.exists():
        return set()
    return {p.stem for p in d.glob("*.json") if not p.name.endswith(".legacy.json")}


# ---------------------------------------------------------------- браузер
def open_window(url: str) -> dict:
    """Новое ОКНО Chrome (а не вкладка) через браузерный CDP-эндпоинт."""
    ver = hv.http_json("/json/version")
    browser = hv.CDP(ver["webSocketDebuggerUrl"])
    try:
        tid = browser.send("Target.createTarget", {"url": url, "newWindow": True})["targetId"]
    finally:
        browser.close()
    for _ in range(40):
        for t in hv.http_json("/json/list"):
            if t.get("id") == tid:
                return t
        time.sleep(0.25)
    raise RuntimeError("окно не появилось")


def activate(target_id: str) -> None:
    """Вынести окно на передний план."""
    ver = hv.http_json("/json/version")
    browser = hv.CDP(ver["webSocketDebuggerUrl"])
    try:
        browser.send("Target.activateTarget", {"targetId": target_id})
    except RuntimeError:
        pass
    finally:
        browser.close()


def site_target(site: str, create: bool = True) -> dict | None:
    host = SITES[site]["host"]
    for t in hv.http_json("/json/list"):
        if t.get("type") == "page" and host in (t.get("url") or ""):
            return t
    return open_window(SITES[site]["home"]) if create else None


def connect_site(site: str):
    if not hv.chrome_start(SITES[site]["home"]):
        raise RuntimeError("не удалось запустить Chrome")
    target = site_target(site)
    cdp = hv.CDP(target["webSocketDebuggerUrl"])
    cdp.send("Page.enable")
    cdp.send("Runtime.enable")
    return cdp


LOGIN_JS = """JSON.stringify((() => {
  const q = s => !!document.querySelector(s);
  const head = document.body ? document.body.innerText.slice(0, 4000) : '';
  return {
    out: q('a[href*="logout"], #logged-in-username'),
    guest: q('form[action*="login"]') || /Гость!|Зарегистрируйтесь/.test(head),
    title: document.title
  };
})())"""


def login_state(info: dict) -> str:
    """'in' — вошли, 'guest' — гость, 'unknown' — не удалось определить."""
    if info.get("out"):
        return "in"
    if info.get("guest"):
        return "guest"
    return "unknown"


def check_login(site: str) -> str:
    cdp = connect_site(site)
    try:
        nav = hv.goto(cdp, SITES[site]["home"], min_len=300, timeout=60)
        if not nav["ok"]:
            return "unknown"
        return login_state(json.loads(cdp.eval(LOGIN_JS) or "{}"))
    finally:
        cdp.close()


def cmd_windows(sites: list[str], wait: bool = True) -> None:
    if not hv.chrome_start(SITES[sites[0]]["home"]):
        say("Chrome не запустился (проверьте путь в harvest_core.CHROME_PATHS)")
        return
    say(f"Chrome: порт {hv.CHROME_PORT}, профиль {hv.CHROME_PROFILE}")
    for s in sites:
        activate(site_target(s)["id"])
        say(f"окно {s}: {SITES[s]['home']}")
    if wait:
        say("\nОткрылись окна Chrome (если их не видно — проверьте панель задач).")
        say("Пароль вводится ТОЛЬКО в этих окнах браузера, не в консоли.")
        input("Войдите в аккаунт в каждом окне (Cloudflare тоже пройдите там) "
              "и нажмите Enter здесь… ")
    names = {"in": "вошли", "guest": "гость — войдите", "unknown": "не определено"}
    for s in sites:
        try:
            st = check_login(s)
        except Exception as exc:                                  # noqa: BLE001
            st = "unknown"
            say(f"{exc}", s)
        say(f"{s:10s}: {names[st]}")


# ---------------------------------------------------------------- сбор
def fetch_release(cdp, site: str, rid: str) -> dict:
    if site == "rutracker":
        rec = hv.rt_topic(cdp, rid)
    elif site == "nnm":
        rec = hv.nnm_topic(cdp, rid)
    else:
        rec = hv.kz_release(cdp, rid)
    if rec.get("ok"):
        if site == "kinozal":
            if not (rec.get("release_tab") or "").strip():       # вкладка не успела загрузиться
                rec["release_tab"] = hv.kz_read_tab(cdp, rid, 0, timeout=10)
            if not (rec.get("tech_tab") or "").strip():
                rec["tech_tab"] = hv.kz_read_tab(cdp, rid, 100, timeout=10)
            hv.kz_read_tab(cdp, rid, 0)          # вернуть вкладку «Описание» перед снимком HTML
        rec["_html"] = snapshot_html(cdp)
    return rec


# Снимок страницы «как на сайте»: с кодировкой, адресом (картинки грузятся с сайта) и стилями.
# Таблицы стилей выносятся в data/raw/_css/<хеш>.css (одна на все страницы), в HTML — ссылка.
SNAPSHOT_JS = (Path(__file__).resolve().parent / "snapshot.js").read_text(encoding="utf-8")
CSS_DIR_NAME = "_css"


def store_css(text: str) -> str:
    """Таблица стилей -> data/raw/_css/<хеш>.css; возвращает имя файла."""
    import hashlib
    name = hashlib.sha1(text.encode("utf-8")).hexdigest()[:12] + ".css"
    d = RAW / CSS_DIR_NAME
    d.mkdir(parents=True, exist_ok=True)
    if not (d / name).exists():
        (d / name).write_text(text, encoding="utf-8")
    return name


def snapshot_html(cdp) -> str:
    """Читаемый снимок открытой страницы: UTF-8, <base>, стили файлами. Пусто, если не получилось."""
    try:
        snap = json.loads(cdp.eval(SNAPSHOT_JS) or "{}")
    except (json.JSONDecodeError, TypeError):
        snap = {}
    html = snap.get("html") or ""
    for i, css in enumerate(snap.get("css") or []):
        html = html.replace(f"@@CSS{i}@@", f"../{CSS_DIR_NAME}/{store_css(css)}")
    return html or (cdp.eval("document.documentElement.outerHTML") or "")


def cmd_repair_html(with_css: bool = True) -> dict:
    """Старые сохранённые страницы -> читаемые: кодировка UTF-8, <base> и стили сайта.

    Время изменения файлов не меняется, поэтому кэши «уже разобрано» остаются в силе.
    Стили берутся один раз с живой страницы каждого трекера (нужен Chrome и вход).
    """
    import re as _re
    stats = {"fixed": 0, "already": 0, "css_sites": 0}
    bases = {"rutracker": "https://rutracker.org/forum/", "nnm": "https://nnmclub.to/forum/",
             "kinozal": "https://kinozal.me/"}
    for site in SITES:
        d = RAW / site
        files = [p for p in sorted(d.glob("*.html"))] if d.exists() else []
        if not files:
            continue
        links = ""
        if with_css:
            try:
                cdp = connect_site(site)
                try:
                    hv.goto(cdp, SITES[site]["home"], min_len=300, timeout=60)
                    snap = json.loads(cdp.eval(SNAPSHOT_JS) or "{}")
                finally:
                    cdp.close()
                links = "".join(f'<link rel="stylesheet" href="../{CSS_DIR_NAME}/{store_css(c)}">'
                                for c in snap.get("css") or [])
                stats["css_sites"] += bool(links)
            except Exception as exc:                          # noqa: BLE001
                say(f"стили {site} не получены: {exc}", site)
        prog = ui.progress()
        with prog:
            task = prog.add_task(f"{site}: правка HTML", total=len(files))
            for hp in files:
                prog.advance(task)
                text = hp.read_text(encoding="utf-8", errors="replace")
                if _re.search(r"(?i)<meta[^>]+charset", text[:3000]):
                    stats["already"] += 1
                    continue
                add = f'<meta charset="utf-8"><base href="{bases[site]}">{links}'
                new, n = _re.subn(r"(?i)(<head[^>]*>)", lambda m: m.group(1) + add, text, count=1)
                if not n:
                    new = f"<!DOCTYPE html><html><head>{add}</head><body>{text}</body></html>"
                st = hp.stat()
                hp.write_text(new, encoding="utf-8")
                os.utime(hp, ns=(st.st_atime_ns, st.st_mtime_ns))
                stats["fixed"] += 1
    say("repair-html: " + ", ".join(f"{k}={v}" for k, v in stats.items()))
    return stats


def has_body(site: str, rec: dict) -> bool:
    if site == "kinozal":
        return bool((rec.get("release_tab") or "").strip())
    return len((rec.get("post") or "").strip()) >= 30


def save_release(site: str, rec: dict) -> None:
    d = RAW / site
    d.mkdir(parents=True, exist_ok=True)
    rid = str(rec["id"])
    html = rec.pop("_html", "")
    (d / f"{rid}.html").write_text(html, encoding="utf-8")
    rec["fetched"] = hv.stamp()
    # json пишется последним: он же признак «сохранено целиком»
    (d / f"{rid}.json").write_text(json.dumps(rec, ensure_ascii=False), encoding="utf-8")


_state_lock = threading.Lock()


def load_state() -> dict:
    try:
        return json.loads(STATE.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        return {}


def update_state(site: str, ref: str, **fields) -> None:
    with _state_lock:
        st = load_state()
        st.setdefault(site, {}).setdefault(ref, {}).update(fields, updated=hv.stamp())
        RAW.mkdir(parents=True, exist_ok=True)
        STATE.write_text(json.dumps(st, ensure_ascii=False, indent=2), encoding="utf-8")


SECTIONS = RAW / "_sections.json"


def load_sections() -> dict:
    try:
        return json.loads(SECTIONS.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        return {}


def save_sections(cache: dict) -> None:
    RAW.mkdir(parents=True, exist_ok=True)
    tmp = SECTIONS.with_suffix(".tmp")
    tmp.write_text(json.dumps(cache, ensure_ascii=False, indent=2), encoding="utf-8")
    tmp.replace(SECTIONS)


class quiet_harvest:
    """Глушит построчный лог harvest_core (в панели с прогрессом он только мешает)."""

    def __enter__(self):
        self._old, hv.log = hv.log, (lambda *_a, **_k: None)

    def __exit__(self, *exc):
        hv.log = self._old


def ensure_sections(sites: list[str], force: bool = False) -> dict:
    """Находит разделы с зарубежными фильмами/сериалами (первый запуск) и кэширует.

    Кэш: data/raw/_sections.json. Повторно ищем только с force=True.
    """
    import discover
    from rich.progress import (BarColumn, MofNCompleteColumn, Progress, SpinnerColumn,
                               TextColumn, TimeElapsedColumn)

    cache = load_sections()
    for s in sites:
        created = cache.get("created", {}).get(s)
        age = (time.time() - time.mktime(time.strptime(created, "%Y-%m-%d %H:%M:%S"))) / 86400 \
            if created else None
        fresh = (cache.get("version", {}).get(s) == discover.RULES_VERSION
                 and age is not None and age < discover.SECTIONS_TTL_DAYS)
        if cache.get(s) and fresh and not force:
            ui.console.print(f"[dim]Разделы {s}: из кэша, {len(cache[s])} шт., "
                             f"обновлено {created} (повторный поиск: «Дополнительно» → 7)[/]")
            continue
        old = cache.get(s) or []
        probes = cache.setdefault("probes", {}).setdefault(s, {})
        entries: list[dict] = []
        with quiet_harvest(), Progress(
                SpinnerColumn(), TextColumn("[bold]{task.description}"), BarColumn(),
                MofNCompleteColumn(), TimeElapsedColumn(), TextColumn("[dim]{task.fields[cur]}"),
                console=ui.console, transient=True) as prog:
            task = prog.add_task(f"Поиск разделов: {s}", total=None, cur="подключение")
            try:
                cdp = connect_site(s)
                try:
                    if s == "kinozal":
                        prog.update(task, cur="проверяю адреса списков")
                        entries = [{**x, "topics": None, "keep": True, "status": "ok"}
                                   for x in discover.kinozal_plan(cdp, lambda *_a: None)]
                    else:
                        def on_probe(ref, n, probes=probes):
                            probes[ref] = n
                            save_sections(cache)          # сохраняем по ходу: прерванный поиск не пропадает
                        entries = discover.discover_forums(
                            cdp, s, on_stage=lambda t: prog.update(task, cur=t),
                            on_step=lambda i, n, name: prog.update(task, total=n, completed=i,
                                                                   cur=name[:60]),
                            probes=probes, on_probe=on_probe)
                finally:
                    cdp.close()
            except Exception as exc:                              # noqa: BLE001
                ui.console.print(f"[red]{s}: поиск разделов не удался: {exc}[/]")
                continue
        found = [{"ref": e["ref"], "name": e["name"], "topics": e["topics"]}
                 for e in entries if e["keep"]]
        ui.console.print(ui.sections_table(s, entries))
        if old and len(found) < 0.6 * len(old) and cache.get("version", {}).get(s) == discover.RULES_VERSION:
            ui.console.print(f"[yellow]{s}: найдено {len(found)} против {len(old)} — похоже на "
                             f"неполную загрузку, прежний список сохранён[/]")
            continue
        if found:
            cache[s] = found
            cache.setdefault("created", {})[s] = hv.stamp()
            cache.setdefault("version", {})[s] = discover.RULES_VERSION
            save_sections(cache)
    return cache


def section_refs(site: str) -> list[str]:
    return [x["ref"] for x in load_sections().get(site, [])]


def choose_refs(site: str) -> str:
    found = section_refs(site)
    if found:
        if ask(f"{site}: найдено разделов {len(found)}. Использовать? (Y/n)", "y").lower() != "n":
            return ",".join(found)
    return ask(f"{site}: {SITES[site]['what']}", SITES[site]["refs"])


def list_ids(cdp, site: str, ref: str, page: int) -> tuple[bool, list[str]]:
    if site == "kinozal":
        return hv.kz_browse_ids(cdp, hv.kz_page_url(ref, page))
    fn = hv.rt_forum_page if site == "rutracker" else hv.nnm_forum_page
    ok, items = fn(cdp, ref, page)
    return ok, [it["id"] for it in items]


def list_items(cdp, site: str, ref: str, page: int) -> tuple[bool, list[dict]]:
    """Страница списка раздела -> (открылась, [{id, text}]) с заголовками тем."""
    if site == "kinozal":
        return hv.kz_browse_items(cdp, hv.kz_page_url(ref, page))
    return (hv.rt_forum_page if site == "rutracker" else hv.nnm_forum_page)(cdp, ref, page)


DEAD = RAW / "_dead.json"


def load_dead(site: str) -> set[str]:
    """id удалённых/несуществующих раздач: повторно не открываем."""
    try:
        return set(json.loads(DEAD.read_text(encoding="utf-8")).get(site, []))
    except (OSError, json.JSONDecodeError):
        return set()


def mark_dead(site: str, rid: str) -> None:
    with _state_lock:
        try:
            data = json.loads(DEAD.read_text(encoding="utf-8"))
        except (OSError, json.JSONDecodeError):
            data = {}
        data[site] = sorted(set(data.get(site, [])) | {rid})
        RAW.mkdir(parents=True, exist_ok=True)
        DEAD.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")


def is_dead(rec: dict) -> bool:
    return not rec.get("ok") and "нет раздачи" in (rec.get("error") or "").lower()


def _on_retry(url: str, attempt: int, retries: int, reason: str) -> None:
    """Страница вернула ошибку сервера/Cloudflare: покажем повтор в панели сбора."""
    for site, info in SITES.items():
        if info["host"] in url:
            ui.get_stats(site).state = f"повтор {attempt}/{retries}: {reason}"
            return


hv.RETRY_HOOK = _on_retry


def section_name(site: str, ref: str) -> str:
    for x in load_sections().get(site, []):
        if x["ref"] == ref:
            return x["name"]
    return ref


def stats_start(site: str, limit: int) -> "ui.Stats":
    """Один трекер может пройти два этапа подряд (дозагрузка и новые): лимиты складываются."""
    st = ui.get_stats(site)
    if not st.started or st.finished:
        st.begin(limit)
    else:
        st.limit += limit
    st.finished = 0.0
    return st


class Tabs:
    """Несколько вкладок одного трекера в общем Chrome (cookie и вход общие).

    Первая — окно, где вы входили; остальные открываются фоном и закрываются в конце.
    Число вкладок: переменная DUB_TABS (по умолчанию 3).
    """

    def __init__(self, site: str, n: int | None = None):
        n = max(1, int(n or os.environ.get("DUB_TABS", 3)))
        self.main = connect_site(site)
        self.cdps = [self.main]
        self.extra: list[str] = []
        for _ in range(n - 1):
            try:
                tab = hv.http_json("/json/new?about:blank", method="PUT")
                cdp = hv.CDP(tab["webSocketDebuggerUrl"])
                cdp.send("Page.enable")
                cdp.send("Runtime.enable")
            except Exception:                                     # noqa: BLE001
                break                                             # не вышло — работаем с тем, что есть
            self.cdps.append(cdp)
            self.extra.append(tab["id"])

    def close(self) -> None:
        for cdp in self.cdps:
            cdp.close()
        for tid in self.extra:
            try:
                hv.http_json(f"/json/close/{tid}")
            except Exception:                                     # noqa: BLE001
                pass


HARD_LIMIT_S = 150      # одна раздача дольше этого — считаем соединение зависшим
SLOW_S = 40             # дольше этого — помечаем в списке ошибок


def harvest_ids(cdps, site: str, ids: list[str], limit: int, delay: float,
                stop: threading.Event, section: str = "") -> int:
    """Скачивает раздачи параллельно: по рабочему на вкладку. Возвращает число сохранённых."""
    cdps = list(cdps) if isinstance(cdps, (list, tuple)) else [cdps]
    st = ui.get_stats(site)
    todo = deque(ids)
    lock = threading.Lock()
    done = [0]
    st.state = "скачиваю"

    def worker(cdp) -> None:
        while not stop.is_set():
            with lock:
                if done[0] >= limit or not todo:
                    return
                rid = todo.popleft()
                done[0] += 1                              # слот под лимит занят заранее
            st.state = f"скачиваю {rid}"
            saved = False
            t_start = time.time()
            guard = threading.Timer(HARD_LIMIT_S, cdp.abort)    # сторож: зависший вызов обрывается
            guard.daemon = True
            guard.start()
            try:
                rec = fetch_release(cdp, site, rid)
                if is_dead(rec):                          # удалена: запоминаем и идём дальше
                    mark_dead(site, rid)
                    st.skipped += 1
                elif rec.get("ok") and has_body(site, rec):
                    rec["section_ref"] = section
                    save_release(site, rec)
                    st.ok(f"{rid} {rec.get('title') or rec.get('h1') or rec.get('page_title') or ''}")
                    saved = True
                else:
                    st.fail(f"{rid}: нет текста раздачи (нужен вход? {rec.get('error', '')})")
            except Exception as exc:                          # noqa: BLE001
                st.fail(f"{rid}: {exc}")
            finally:
                guard.cancel()
            if time.time() - t_start > HARD_LIMIT_S:             # сторож сработал: соединение мертво
                st.fail(f"{rid}: завис на {time.time() - t_start:.0f} с, вкладка переподключена")
                try:
                    cdp.reconnect()
                except Exception as exc:                      # noqa: BLE001
                    st.fail(f"переподключение не удалось: {exc}")
                    return
            elif time.time() - t_start > SLOW_S:
                st.fail(f"{rid}: медленно, {time.time() - t_start:.0f} с")      # видно, на каких страницах
            if not saved:
                with lock:
                    done[0] -= 1                          # неудача не съедает лимит
            time.sleep(delay + random.random() * 0.5)

    helpers = [threading.Thread(target=worker, args=(c,), daemon=True) for c in cdps[1:]]
    for t in helpers:
        t.start()
    worker(cdps[0])
    for t in helpers:
        t.join()
    return done[0]


def collect_ref_balanced(site: str, ref: str, cdp, tabs: "Tabs", have: set, counts, ref_quota: int,
                         limit_left: int, delay: float, stop: threading.Event, per_page: int,
                         rng: random.Random) -> int:
    """Раздел вразброс: страницы по всей глубине, на странице — темы из недопредставленных
    корзин (год × качество × фильм/сериал). Возвращает число сохранённых раздач."""
    import diversity as dv
    stat = ui.get_stats(site)
    st = load_state().get(site, {}).get(ref, {})
    visited = set(st.get("visited", []))
    depth = int(st.get("depth") or 0)
    saved, fails = 0, 0
    for _ in range(300):
        if stop.is_set() or saved >= min(ref_quota, limit_left) or fails >= 3:
            break
        page = 0 if not depth else (next_pg[0] if (next_pg := dv.next_pages(depth, visited, 1, rng)) else None)
        if page is None:                                      # раздел обойден целиком: начинаем новый круг
            update_state(site, ref, visited=[], finished=True)
            break
        stat.state = f"список, стр.{page + 1}" + (f"/{depth}" if depth else "")
        ok, items = list_items(cdp, site, ref, page)
        if not ok:
            fails += 1
            stat.fail(f"{stat.section}: стр.{page + 1} не открылась")
            visited.add(page)
            continue
        visited.add(page)
        seen_depth = hv.list_depth(cdp)
        if not items:                                         # дальше конца раздела
            depth = max(1, page) if page else 1
            update_state(site, ref, visited=sorted(v for v in visited if v < depth), depth=depth)
            continue
        depth = max(depth, seen_depth, page + 1)
        fresh = [it for it in items if it["id"] not in have]
        want = min(per_page, ref_quota - saved, limit_left - saved)
        chosen = dv.pick(fresh, want, counts, rng)
        n = harvest_ids(tabs.cdps, site, [it["id"] for it in chosen], want, delay, stop, section=ref)
        have |= stored_ids(site)
        saved += n
        update_state(site, ref, visited=sorted(visited), depth=depth, next_page=0)
    return saved


def run_collect(site: str, refs: list[str], pages: int, limit: int, delay: float,
                stop: threading.Event, from_page: int | None = None) -> int:
    """Новые раздачи из списков разделов; уже размеченные и сохранённые пропускаются.

    Лимит делится между разделами поровну, чтобы в выборку попали все форматы и годы.
    """
    have = stored_ids(site) | labeled_real_ids(site) | load_dead(site)
    stat = stats_start(site, limit)
    stat.state = "подключение"
    tabs = Tabs(site)
    cdp = tabs.main
    total = 0
    quota = max(1, -(-limit // max(len(refs), 1)))
    cfg = settings()
    balanced = cfg.get("mode") == "balanced" and from_page is None
    if balanced:
        import diversity as dv
        counts = dv.counts_from_meta(META, site)
        rng = random.Random()
    try:
        for ref in refs:
            if balanced:
                if stop.is_set() or total >= limit:
                    break
                stat.section = section_name(site, ref)
                ref_quota = quota * 3 if "v=0&d=0" in ref else quota
                total += collect_ref_balanced(site, ref, cdp, tabs, have, counts, ref_quota,
                                              limit - total, delay, stop, int(cfg.get("per_page", 6)), rng)
                continue
            st = load_state().get(site, {}).get(ref, {})
            # раздел уже дочитан до конца: новые раздачи появляются сверху, начинаем со стр.1
            start = (0 if st.get("finished") else st.get("next_page", 0)) if from_page is None else from_page
            if st.get("finished"):
                update_state(site, ref, finished=False, next_page=0)
            ref_total = 0
            stat.section = section_name(site, ref)
            # общие списки kinozal (все фильмы / сериалы / мульты / аниме) весят втрое больше сетки
            ref_quota = quota * 3 if "v=0&d=0" in ref else quota
            for k in range(pages):
                if stop.is_set() or total >= limit or ref_total >= ref_quota:
                    break
                page = start + k
                stat.state = f"список, стр.{page + 1}"
                ok, ids = list_ids(cdp, site, ref, page)
                if not ok:
                    stat.fail(f"{stat.section}: стр.{page + 1} не открылась")
                    break
                if not ids:
                    update_state(site, ref, finished=True)
                    break
                fresh = [i for i in ids if i not in have]
                n = harvest_ids(tabs.cdps, site, fresh, min(limit - total, ref_quota - ref_total),
                                delay, stop, section=ref)
                have |= stored_ids(site)
                total += n
                ref_total += n
                complete = n == len(fresh) and not stop.is_set()
                update_state(site, ref, next_page=page + 1 if complete else page)
                if not complete:
                    break
    finally:
        tabs.close()
        stat.done("остановлено" if stop.is_set() else "готово")
    return total


def backfill_ids(site: str, missing_pages_only: bool = True) -> list[str]:
    """Размеченные раздачи, у которых нет ни сохранённой страницы, ни data/pages."""
    have = stored_ids(site) | load_dead(site)
    labeled = labeled_ids()
    ids = []
    for release_id in sorted(labeled.get(site, set())):
        rid = real_id(site, release_id)
        if rid in have or (missing_pages_only and (PAGES / f"{release_id}.txt").exists()):
            continue
        ids.append(rid)
    random.Random(7).shuffle(ids)          # ограниченный лимит -> разнообразная выборка
    return ids


def run_backfill(site: str, limit: int, delay: float, stop: threading.Event) -> int:
    ids = backfill_ids(site)
    stat = stats_start(site, min(limit, len(ids)))
    stat.section = f"дозагрузка размеченных (осталось {len(ids)})"
    if not ids:
        stat.done()
        return 0
    stat.state = "подключение"
    tabs = Tabs(site)
    try:
        n = harvest_ids(tabs.cdps, site, ids, limit, delay, stop, section="backfill")
    finally:
        tabs.close()
        stat.done("остановлено" if stop.is_set() else "готово")
    return n


def run_threads(jobs: dict, stop: threading.Event) -> None:
    """jobs: {site: callable}. По потоку на трекер (у каждого своё окно и свой CDP)."""
    ui.STATS.clear()
    sites = list(jobs)
    threads = [threading.Thread(target=fn, name=s, daemon=True) for s, fn in jobs.items()]
    for t in threads:
        t.start()
    with ui.live(sites):
        try:
            while any(t.is_alive() for t in threads):
                time.sleep(0.25)
        except KeyboardInterrupt:
            stop.set()
            for s in sites:
                ui.get_stats(s).state = "останавливаюсь…"
            for t in threads:
                t.join(timeout=90)
    ui.console.print(ui.dashboard(sites))


def safe(site: str, fn):
    def run():
        try:
            fn()
        except Exception as exc:                                  # noqa: BLE001
            say(f"ошибка: {exc}", site)
    return run


# ---------------------------------------------------------------- сборка pages/labels
PAR_MIN = 40           # меньше задач — быстрее в одном процессе, чем поднимать пул


def worker_count() -> int:
    """Процессов для переиндексации: настройка `workers`, иначе число ядер минус два (не больше 12)."""
    try:
        n = int(settings().get("workers") or 0)
    except (TypeError, ValueError):
        n = 0
    return n if n > 0 else max(1, min(12, (os.cpu_count() or 2) - 2))


class Runner:
    """Пул процессов на время переиндексации; для малых задач и workers=1 считает на месте."""

    def __init__(self, workers: int | None = None) -> None:
        self.workers = workers or worker_count()
        self.pool = None

    def map(self, fn, tasks: list, chunk: int = 8):
        """Результаты в порядке задач (по мере готовности)."""
        if self.workers <= 1 or len(tasks) < PAR_MIN:
            for t in tasks:
                yield fn(t)
            return
        if self.pool is None:
            from concurrent.futures import ProcessPoolExecutor
            self.pool = ProcessPoolExecutor(max_workers=self.workers)
        yield from self.pool.map(fn, tasks, chunksize=chunk)

    def close(self) -> None:
        if self.pool is not None:
            self.pool.shutdown(wait=True, cancel_futures=True)
            self.pool = None


def cmd_build(rewrite: bool = False, relabel: bool = False, runner: "Runner | None" = None) -> dict:
    """data/raw -> data/pages/*.txt и новые строки в data/labels.csv.

    relabel: метки уже размеченных релизов, у которых сохранён HTML, строятся
    заново текущими парсерами (старые строки заменяются; ручные метки и релизы
    без HTML не трогаются; если парсер ничего не нашёл — остаются прежние).
    Разбор идёт в нескольких процессах (настройка workers, по умолчанию ядра − 2).
    """
    import rebuild_workers as rw

    if migrate_labels():
        say("labels.csv: добавлены колонки lang и audio_raw (копия: labels.bak_schema.csv)")
    own_runner = runner is None
    runner = runner or Runner()
    rows = read_labels()
    labeled = labeled_ids(rows)
    PAGES.mkdir(parents=True, exist_ok=True)
    new_rows: list[dict] = []
    replaced: set[tuple[str, str]] = set()                    # (источник, release_id) с новыми метками
    manual = set(MANUAL.read_text(encoding="utf-8").split()) if MANUAL.exists() else set()
    stats = {"pages": 0, "labeled": 0, "skipped_no_labels": 0, "unchanged": 0}
    postonly = set(POSTONLY.read_text(encoding="utf-8").split()) if POSTONLY.exists() else set()
    built = {} if rewrite else load_json(RAW / "_built.json")         # что уже разобрано: «подпись» файлов + имя страницы
    t0 = time.time()
    per: dict[str, dict] = {}
    prog = ui.progress()
    prog.start()
    try:
        for site in SITES:
            d = RAW / site
            if not d.exists():
                continue
            done = built.setdefault(site, {})
            files = [jp for jp in sorted(d.glob("*.json"))
                     if not jp.name.endswith(".legacy.json") and jp.with_suffix(".html").exists()]
            ps = per[site] = {"files": len(files), "unchanged": 0, "pages": 0, "relabeled": 0,
                              "new": 0, "no_labels": 0, "t": time.time()}
            task_id = prog.add_task(f"{site}: разбор HTML", total=len(files))
            # проход 1 (быстрый, на месте): что изменилось и что с ним делать
            jobs: list[dict] = []
            for jp in files:
                hp = jp.with_suffix(".html")
                sig = file_sig(jp, hp)
                prev = done.get(jp.stem)
                if prev and prev["sig"] == sig and (
                        prev["stem"] is None or (PAGES / f"{prev['stem']}.txt").exists()):
                    stats["unchanged"] += 1                           # файлы и парсер не менялись
                    ps["unchanged"] += 1
                    prog.advance(task_id)
                    continue
                rid = jp.stem
                stem = page_stem(site, rid, labeled)
                known = rid in labeled.get(site, ()) or stem in labeled.get(site, ())
                page = PAGES / f"{stem}.txt"
                # полная страница заменяет урезанную (текст поста) из импорта старого harvest
                jobs.append({"site": site, "json": str(jp), "html": str(hp), "sig": sig, "stem": stem,
                             "known": known, "parse": not known or (relabel and stem not in manual),
                             "page": str(page) if (rewrite or not page.exists() or stem in postonly) else None})
            # проход 2: разбор HTML и запись страниц — параллельно
            for job, res in zip(jobs, runner.map(rw.build_one, jobs)):
                prog.advance(task_id)
                rid, stem = Path(job["json"]).stem, job["stem"]
                done[rid] = {"sig": job["sig"], "stem": stem}
                if res["error"]:
                    say(f"{site} {rid}: разбор не удался: {res['error']}")
                if res["skipped"]:
                    stats["skipped_no_labels"] += 1
                    ps["no_labels"] += 1
                    done[rid]["stem"] = None
                    continue
                if res["error"] and not job["known"]:
                    continue
                if res["wrote"]:
                    stats["pages"] += 1
                    ps["pages"] += 1
                    if stem in postonly:
                        postonly.discard(stem)
                        stats["upgraded"] = stats.get("upgraded", 0) + 1
                labs = res["labs"]
                for r in labs:
                    r["release_id"] = stem
                    new_rows.append(r)
                if labs and job["known"]:
                    replaced.add((site, stem))
                    ps["relabeled"] += 1
                elif labs:
                    ps["new"] += 1
                if labs:
                    stats["labeled"] += 1
    finally:
        prog.stop()
    if replaced:
        import shutil
        backup = LABELS.with_name(f"labels.bak_{time.strftime('%Y%m%d_%H%M%S')}.csv")
        shutil.copy2(LABELS, backup)
        old = [r for r in rows if (r["source"], r["release_id"]) not in replaced]
        stats["relabeled"], stats["rows_before"] = len(replaced), len(rows)
        with LABELS.open("w", encoding="utf-8-sig", newline="") as f:
            w = csv.DictWriter(f, fieldnames=hv.FIELDS, extrasaction="ignore")
            w.writeheader()
            w.writerows(old)
        stats["backup"] = backup.name
    if new_rows:
        fresh_file = not LABELS.exists() or LABELS.stat().st_size == 0
        with LABELS.open("a", encoding="utf-8-sig" if fresh_file else "utf-8", newline="") as f:
            w = csv.DictWriter(f, fieldnames=hv.FIELDS, extrasaction="ignore")
            if fresh_file:
                w.writeheader()
            w.writerows(new_rows)
    stats["new_label_rows"] = len(new_rows)
    if POSTONLY.exists():
        POSTONLY.write_text("\n".join(sorted(postonly)) + ("\n" if postonly else ""), encoding="utf-8")
    save_json(RAW / "_built.json", built)
    try:
        m = cmd_meta(rewrite, runner)
    finally:
        if own_runner:
            runner.close()
    stats["meta_rows"], stats["meta_reused"] = m["rows"], m["reused"]
    ui.console.print(ui.summary_table("Итоги переиндексации", [
        "трекер", "файлов HTML", "без изменений", "страниц записано", "метки пересчитаны",
        "новые релизы", "без меток", "сек"],
        [[s_, p_["files"], p_["unchanged"], p_["pages"], p_["relabeled"], p_["new"], p_["no_labels"],
          f"{time.time() - p_['t']:.0f}"] for s_, p_ in per.items()]
        + [["meta.csv", m["rows"] + 0, f"из кэша {m['reused']}", "", "", "", "",
            f"{time.time() - t0:.0f} всего, процессов {runner.workers}"]]))
    say("build: " + ", ".join(f"{k}={v}" for k, v in stats.items()))
    return stats


# Версия разбора: поднимите при правке парсеров (harvest_core, html_to_text) — тогда
# кэш «уже разобрано» сбросится сам и данные пересоберутся один раз.
PARSE_VERSION = 2


def load_json(path: Path) -> dict:
    try:
        return json.loads(path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        return {}


def save_json(path: Path, data: dict) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    tmp = path.with_suffix(".tmp")
    tmp.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
    tmp.replace(path)


def file_sig(*paths: Path) -> str:
    """Подпись входа: время и размер файлов + версия разбора."""
    parts = [f"{p.stat().st_mtime_ns}:{p.stat().st_size}" for p in paths if p.exists()]
    return "|".join(parts) + f"|v{PARSE_VERSION}"


def cmd_meta(rewrite: bool = False, runner: "Runner | None" = None) -> dict:
    """data/raw (и импорт старого harvest) -> data/meta.csv: одна строка на релиз.

    Строки кэшируются (data/raw/_meta_cache.json) по подписи файлов, версии
    извлекателя и названия раздела: разбирается только новое и изменённое.
    Текст страницы берётся из data/pages (уже разобран при сборке), а не из HTML заново;
    извлечение идёт в нескольких процессах.
    """
    import rebuild_workers as rw

    own_runner = runner is None
    runner = runner or Runner()
    labeled = labeled_ids()
    cache = {} if rewrite else load_json(RAW / "_meta_cache.json")
    fresh_cache: dict[str, dict] = {}
    out: list[dict] = []
    reused = 0
    prog = ui.progress()
    prog.start()
    try:
        for site in SITES:
            d = RAW / site
            if not d.exists():
                continue
            files: dict[str, Path] = {}
            for jp in sorted(d.glob("*.json"), key=lambda p: not p.name.endswith(".legacy.json")):
                files[jp.name.split(".")[0]] = jp                  # legacy идут первыми, полные их заменят
            task_id = prog.add_task(f"{site}: meta.csv", total=len(files))
            jobs: list[dict] = []
            for key, jp in files.items():
                hp = jp.with_suffix(".html")
                ck = f"{site}:{key}"
                sig = f"{file_sig(jp, hp)}|m{metamod.META_VERSION}"
                hit = cache.get(ck)
                if hit and hit["sig"] == sig:
                    rec_ref = hit["ref"]
                    name = section_name(site, rec_ref) if rec_ref and rec_ref != "backfill" else ""
                    if hit["section"] == name:                    # название раздела не менялось
                        out.append(hit["row"])
                        fresh_cache[ck] = hit
                        reused += 1
                        prog.advance(task_id)
                        continue
                rec = json.loads(jp.read_text(encoding="utf-8"))
                rid = str(rec["id"])
                ref = rec.get("section_ref", "")
                name = section_name(site, ref) if ref and ref != "backfill" else ""
                stem = page_stem(site, rid, labeled)
                jobs.append({"site": site, "rec": rec, "name": name, "html": str(hp), "ck": ck,
                             "sig": sig, "ref": ref, "stem": stem,
                             "page": str(PAGES / f"{stem}.txt") if hp.exists() else None})
            for job, row in zip(jobs, runner.map(rw.meta_one, jobs)):
                prog.advance(task_id)
                row["release_id"] = job["stem"]
                out.append(row)
                fresh_cache[job["ck"]] = {"sig": job["sig"], "ref": job["ref"], "section": job["name"], "row": row}
    finally:
        prog.stop()
        if own_runner:
            runner.close()
    save_json(RAW / "_meta_cache.json", fresh_cache)
    out.sort(key=lambda r: (r["source"], r["release_id"]))
    META.parent.mkdir(parents=True, exist_ok=True)
    with META.open("w", encoding="utf-8-sig", newline="") as f:
        w = csv.DictWriter(f, fieldnames=metamod.FIELDS, extrasaction="ignore")
        w.writeheader()
        w.writerows(out)
    return {"rows": len(out), "reused": reused}


def legacy_text(site: str, rec: dict) -> str:
    """Текст страницы из записи старого harvest (только то, что там сохранено)."""
    if site == "kinozal":
        full = rec.get("page_text") or ""
        tab = (rec.get("release_tab") or "").strip()
        tech = (rec.get("tech_tab") or "").strip()
        parts = [full] + [t for t in (tab, tech) if t and t not in full]
        return "\n\n".join(p for p in parts if p)
    return f"{rec.get('title') or ''}\n\n{rec.get('post') or ''}"


def cmd_import_legacy(src_dir: str) -> dict:
    """Страницы для уже размеченных раздач из старых jsonl (без браузера).

    Это урезанный вход — только текст поста (kinozal: ещё и вкладки). Такие
    страницы перечислены в data/pages_postonly.txt, чтобы оценку на них можно
    было отделять от полных страниц.
    """
    base = Path(src_dir)
    labeled = labeled_ids()
    PAGES.mkdir(parents=True, exist_ok=True)
    added: list[str] = []
    for site in SITES:
        for cand in (base / "raw" / f"{site}.jsonl", base / f"{site}.jsonl"):
            if cand.exists():
                break
        else:
            say(f"{site}: нет {site}.jsonl в {base}")
            continue
        n = 0
        for line in cand.read_text(encoding="utf-8").splitlines():
            if not line.strip():
                continue
            rec = json.loads(line)
            rid = str(rec.get("id"))
            if not rec.get("ok", True) or rid not in labeled.get(site, ()):
                continue
            stem = page_stem(site, rid, labeled)
            page = PAGES / f"{stem}.txt"
            text = legacy_text(site, rec).strip()
            keep = {k: rec[k] for k in ("id", "source", "page_title", "title", "post", "h1",
                                        "release_tab", "tech_tab") if k in rec}
            if rec.get("page_text"):
                keep["page_text"] = rec["page_text"][:8000]
            (RAW / site).mkdir(parents=True, exist_ok=True)
            (RAW / site / f"{rid}.legacy.json").write_text(
                json.dumps(keep, ensure_ascii=False), encoding="utf-8")
            if page.exists() or len(text) < 40:
                continue
            page.write_text(text, encoding="utf-8")
            added.append(stem)
            n += 1
        say(f"{site}: страниц добавлено {n}")
    if added:
        prev = POSTONLY.read_text(encoding="utf-8").split() if POSTONLY.exists() else []
        POSTONLY.write_text("\n".join(sorted(set(prev) | set(added))) + "\n", encoding="utf-8")
    return {"added": len(added)}


# ---------------------------------------------------------------- статус
def read_meta() -> list[dict]:
    if not META.exists():
        return []
    with META.open(encoding="utf-8-sig", newline="") as f:
        return list(csv.DictReader(f))


def coverage_rows() -> list[dict]:
    labeled = labeled_ids()
    pages = {p.stem for p in PAGES.glob("*.txt")} if PAGES.exists() else set()
    postonly = set(POSTONLY.read_text(encoding="utf-8").split()) if POSTONLY.exists() else set()
    meta_cnt = Counter(r["source"] for r in read_meta())
    rows = []
    for site in SITES:
        stems = {page_stem(site, i, labeled) for i in labeled.get(site, set())}
        with_page = stems & pages
        rows.append({"site": site, "labeled": len(stems), "pages": len(with_page),
                     "postonly": len(with_page & postonly), "raw": len(stored_ids(site)),
                     "meta": meta_cnt.get(site, 0), "missing": len(stems - pages)})
    return rows


def cmd_status(detailed: bool = True) -> None:
    """Покрытие датасета, состав по трекерам (тип, разрешение, кодек, годы, языки), прогресс."""
    from rich.columns import Columns
    from rich.panel import Panel
    from rich.table import Table

    ui.console.print(ui.coverage_table(coverage_rows()))
    if not detailed:
        return
    meta = read_meta()
    if meta:
        for site in SITES:
            m = [r for r in meta if r["source"] == site]
            if not m:
                continue
            years = Counter((r["year"][:3] + "0-е") if r["year"] else "—" for r in m)
            langs = Counter(x for r in m for x in r["audio_langs"].split("+") if x)
            blocks = [
                ui.distribution("Тип", Counter(r["kind"] for r in m)),
                ui.distribution("Разрешение", Counter(r["resolution"] or "—" for r in m)),
                ui.distribution("Кодек видео", Counter(r["video_codec"] or "—" for r in m)),
                ui.distribution("Годы", Counter(dict(sorted(years.items(), reverse=True)))),
                ui.distribution("Языки дорожек", langs),
            ]
            ui.console.print(Panel(Columns(blocks, equal=True, expand=True),
                                   title=f"[bold]{site}[/] · {len(m)} релизов",
                                   border_style=ui.SITE_STYLE[site]))
    else:
        say("meta.csv пока нет: запустите import-legacy или «Собрать pages и labels».")
    rows = [(s, ref, v) for s, refs in load_state().items() for ref, v in refs.items()]
    if rows:
        t = Table(title="Прогресс по разделам", title_justify="left")
        for c in ("Трекер", "Раздел", "След. стр.", "Статус"):
            t.add_column(c)
        for s, ref, v in rows:
            t.add_row(s, section_name(s, ref)[:70], str(v.get("next_page", 0) + 1),
                      "список закончился" if v.get("finished") else "идёт")
        ui.console.print(t)


# ---------------------------------------------------------------- меню
def ask(prompt: str, default: str = "") -> str:
    return ui.ask(prompt, default).strip()


def ask_sites(default: str = "rutracker,nnm,kinozal") -> list[str]:
    raw = ask("Трекеры через запятую (rutracker, nnm, kinozal)", default)
    sites = [s.strip() for s in raw.split(",") if s.strip() in SITES]
    return sites or list(SITES)


def wizard_collect() -> None:
    """Пункт 1: окна -> вход -> сбор -> страницы и метки -> data/processed."""
    stop = threading.Event()
    sites = ask_sites()
    cmd_windows(sites)
    say("\nЧто собирать?")
    say(" n  новые раздачи из списков разделов")
    say(" b  страницы для уже размеченных раздач (nnm, kinozal)")
    say(" nb и то и другое")
    mode = ask("Режим", "nb")
    cfg = settings()
    limit = int(ask("Максимум страниц на трекер за запуск", str(cfg["limit"])))
    tabs = clamp_tabs(ask("Вкладок на трекер, параллельно (1–4; больше — быстрее, но выше риск лимитов)",
                          str(cfg["tabs"])))
    delay = float(ask("Пауза между раздачами на одну вкладку, с", str(cfg["delay"])))
    pages = int(ask("Страниц списка на раздел (для режима n)", str(cfg["pages"]))) if "n" in mode else 0
    save_settings({**cfg, "limit": limit, "tabs": tabs, "delay": delay,
                   "pages": pages or cfg["pages"]})              # запоминаем на следующий запуск
    jobs = {}
    if "n" in mode:
        ensure_sections(sites)
    for s in sites:
        refs = choose_refs(s) if "n" in mode else ""

        def job(s=s, refs=refs):
            if "b" in mode:
                run_backfill(s, limit, delay, stop)
            if "n" in mode and not stop.is_set():
                run_collect(s, [r.strip() for r in refs.split(",") if r.strip()],
                            pages, limit, delay, stop)
        jobs[s] = safe(s, job)
    run_threads(jobs, stop)
    say("\nСобираю data/pages и data/labels.csv…")
    cmd_build()
    say("Пересобираю data/processed…")
    import retrain
    if not retrain.prepare():
        say("prepare_data завершился с ошибкой")
        return
    cmd_status()
    say("\nДатасет собран. Дальше — пункт 2 (переобучить и протестировать).")


# ---------------------------------------------------------------- обучение по ссылкам
MANUAL = DATA / "manual_ids.txt"
MODELS_TMP = ROOT / "models" / ".compare.json"
RE_LINK = {
    "rutracker": re.compile(r"rutracker\.[a-z]+/forum/viewtopic\.php\?(?:[^\s#]*&)?t=(\d+)", re.I),
    "nnm": re.compile(r"nnmclub\.[a-z]+/forum/viewtopic\.php\?(?:[^\s#]*&)?t=(\d+)", re.I),
    "kinozal": re.compile(r"kinozal\.[a-z]+/details\.php\?(?:[^\s#]*&)?id=(\d+)", re.I),
}
PARSERS = {"kinozal": hv.kz_parse, "rutracker": hv.rt_parse, "nnm": hv.nnm_parse}


def parse_link(url: str) -> tuple[str, str] | None:
    """Ссылка на раздачу -> (трекер, id раздачи)."""
    for site, rx in RE_LINK.items():
        m = rx.search(url or "")
        if m:
            return site, m.group(1)
    return None


def store_manual(site: str, rec: dict, rows: list[dict], page_text: str) -> str:
    """Записывает проверенные вручную метки релиза.

    Прежние строки этого релиза в labels.csv заменяются, страница кладётся в
    data/pages, id попадает в data/manual_ids.txt (всегда train, усиление).
    """
    migrate_labels()
    labeled = labeled_ids()
    stem = page_stem(site, str(rec["id"]), labeled)
    keep = [r for r in read_labels() if not (r["source"] == site and r["release_id"] == stem)]
    for r in rows:
        r["release_id"] = stem
        r["studio_source"] = "manual"
    PAGES.mkdir(parents=True, exist_ok=True)
    (PAGES / f"{stem}.txt").write_text(page_text, encoding="utf-8")
    with LABELS.open("w", encoding="utf-8-sig", newline="") as f:
        w = csv.DictWriter(f, fieldnames=hv.FIELDS, extrasaction="ignore")
        w.writeheader()
        w.writerows(keep + rows)
    ids = set(MANUAL.read_text(encoding="utf-8").split()) if MANUAL.exists() else set()
    MANUAL.write_text("\n".join(sorted(ids | {stem})) + "\n", encoding="utf-8")
    return stem


def _rows_table(rows: list[dict]):
    from rich import box
    from rich.table import Table
    t = Table(box=box.SIMPLE_HEAD, expand=True, pad_edge=False)
    for col in ("#", "студия", "тип", "18+", "кодек", "кбит/с", "строка"):
        t.add_column(col, overflow="ellipsis", no_wrap=col != "строка")
    for i, r in enumerate(rows, 1):
        t.add_row(str(i), r["studio"], r["translation_type"],
                  "[red]18+[/red]" if int(r["age_18"] or 0) else "", r["codec"], r["kbps"],
                  (r["raw"] or "")[:70])
    return t


def edit_rows(rows: list[dict]) -> list[dict]:
    """Ручная правка меток: «2 18», «3 d», «1 t проф. двухголосый», «1 s HDrezka»."""
    while True:
        ui.console.print(_rows_table(rows))
        say("Правка: «N 18» — переключить 18+, «N d» — удалить, «N t <тип>», «N s <студия>»; "
            "Enter — сохранить")
        cmd = ask("Правка", "").strip()
        if not cmd:
            return rows
        parts = cmd.split(None, 2)
        try:
            r = rows[int(parts[0]) - 1]
            op = parts[1]
        except (ValueError, IndexError):
            say("не понял; пример: «2 18»")
            continue
        arg = parts[2] if len(parts) > 2 else ""
        if op == "18":
            now = not int(r["age_18"] or 0)
            r["age_18"] = int(now)
            r["note"] = hv.mark_18(r["note"], True) if now else (r["note"] or "").replace("18+", "").strip()
        elif op == "d":
            rows.remove(r)
        elif op == "t" and arg:
            r["translation_type"] = arg
        elif op == "s" and arg:
            r["studio"] = arg
        else:
            say("не понял; пример: «2 18»")


def wizard_links() -> None:
    """Обучение по конкретным ссылкам: страница -> метки -> ручная правка -> labels.csv."""
    from src.html_extract import html_to_text
    say("Вставьте ссылки на раздачи (rutracker / nnm-club / kinozal), по одной в строке.")
    say("Пустая строка — закончить. Страницы берутся через ваш Chrome (нужен вход).")
    links: list[tuple[str, str]] = []
    while True:
        line = input("> ").strip()
        if not line:
            break
        got = parse_link(line)
        if got is None:
            say(f"не похоже на ссылку на раздачу: {line}")
        elif got not in links:
            links.append(got)
    if not links:
        return
    saved: list[str] = []
    for site in SITES:
        todo = [rid for s, rid in links if s == site]
        if not todo:
            continue
        cdp = connect_site(site)
        try:
            for rid in todo:
                say(f"скачиваю {rid}…", site)
                rec = fetch_release(cdp, site, rid)
                if not rec.get("ok") or not has_body(site, rec):
                    say(f"{rid}: страница не загрузилась ({rec.get('reason', 'пусто')})", site)
                    continue
                html = rec.pop("_html", "")
                rows, _ = PARSERS[site](rec)
                say(f"{rec.get('page_title') or rec.get('title') or rid}", site)
                rows = edit_rows(rows) if rows else []
                if not rows:
                    say("меток нет — релиз не сохранён", site)
                    continue
                save_release(site, {**rec, "_html": html})
                saved.append(store_manual(site, rec, rows, html_to_text(html)))
        finally:
            cdp.close()
    if saved:
        cmd_build()
        say(f"\nДобавлено релизов: {len(saved)} ({', '.join(saved)}). Они всегда идут в train и "
            "повторяются при обучении; модель переучите пунктом «Переобучить».")
        if ask("Переобучить сейчас? (y/N)", "n").lower() == "y":
            wizard_retrain()


class Stages:
    """План шагов с нумерацией, временем каждого шага и итоговой таблицей."""

    def __init__(self, titles: list[str]) -> None:
        self.titles, self.done, self.t0 = titles, [], time.time()
        self.cur: tuple[int, float] | None = None

    def plan(self) -> None:
        ui.console.print("[bold]План:[/bold]")
        for i, t in enumerate(self.titles, 1):
            ui.console.print(f"  [dim]{i}.[/dim] {t}")
        ui.console.print()

    def start(self, title: str) -> None:
        self.finish()
        i = len(self.done) + 1
        ui.console.rule(f"[bold]шаг {i}/{len(self.titles)}[/bold]  {title}  "
                        f"[dim](всего прошло {ui.fmt_time(time.time() - self.t0)})[/dim]")
        self.cur = (i, time.time(), title)

    def finish(self, ok: bool = True) -> None:
        if self.cur:
            self.done.append((self.cur[2], time.time() - self.cur[1], ok))
            self.cur = None

    def summary(self) -> None:
        self.finish(ok=False if self.cur else True)
        ui.console.print(ui.summary_table("Итоги по шагам", ["шаг", "время", "результат"], [
            [t, ui.fmt_time(sec), "ok" if ok else "прервано/ошибка"] for t, sec, ok in self.done]
            + [["всего", ui.fmt_time(time.time() - self.t0), ""]]))


def dataset_stats() -> None:
    """Состав данных перед обучением: размечено, страницы, 18+, ручные метки."""
    rows = read_labels()
    manual = set(MANUAL.read_text(encoding="utf-8").split()) if MANUAL.exists() else set()
    by = Counter(r["source"] for r in rows)
    adult = Counter(r["source"] for r in rows if str(r.get("age_18", "")).strip() in ("1", "True"))
    rel = {(r["source"], r["release_id"]) for r in rows}
    relc = Counter(s_ for s_, _ in rel)
    ui.console.print(ui.summary_table("Данные для обучения", ["трекер", "релизов", "строк-дорожек", "из них 18+"], [
        [s_, relc.get(s_, 0), by.get(s_, 0), adult.get(s_, 0)] for s_ in SITES]
        + [["всего", len(rel), len(rows), sum(adult.values())],
           ["ручные (пункт 6)", len(manual), "", ""]]))


def ask_profiles() -> tuple[list[str], int]:
    """Какие основы обучать и нужна ли кросс-валидация."""
    import retrain
    say("\nОсновы для обучения (каждая — отдельный запуск в models/runs/, models/best не трогается):")
    for name, text in retrain.PROFILES.items():
        say(f"  {name:7s} {text}")
    raw = ask("Профили через запятую", "base")
    profiles = [p.strip() for p in raw.split(",") if p.strip() in retrain.PROFILES] or ["base"]
    say("Кросс-валидация (5 доп. прогонов) нужна только для оценки устойчивости, на итоговую модель не влияет.")
    folds = 5 if ask("С кросс-валидацией? Дольше примерно в 6 раз (y/N)", "n").lower() == "y" else 0
    return profiles, folds


def wizard_retrain() -> None:
    """Пункт 2: (переиндексация) -> prepare -> обучение -> тесты -> сравнение -> подмена весов."""
    import retrain
    say("Данные: сохранённый HTML трекеров можно разобрать заново без захода на сайты.")
    reindex = ask("Переиндексировать data/raw (страницы, метки, meta) текущими парсерами? (y/N)", "n").lower() == "y"
    say("\nЧто переобучать?")
    say(" 1  сегментатор страниц (минуты, GPU)")
    say(" 2  сегментатор + основные модели (тип, автор, 18+, язык; выбор основы и сравнение с прежней лучшей)")
    what = ask("Выбор", "1")
    profiles, folds = ask_profiles() if what == "2" else ([], 0)
    do_prepare = ask("Пересобрать data/processed из data/labels.csv? (Y/n)", "y").lower() != "n"
    train_title = f"Обучение моделей: {', '.join(profiles)}" + (" (+ кросс-валидация)" if folds else "")
    titles = ((["Переиндексация data/raw (страницы, метки, meta)"] if reindex else [])
              + (["prepare_data: data/labels.csv → data/processed"] if do_prepare else [])
              + ([train_title] if what == "2" else [])
              + ["Обучение сегментатора (models/segmenter_v2)", "Тесты проекта",
                 "Сравнение по трекерам (правила / старые веса / новые)"])
    ui.clear()
    st = Stages(titles)
    st.plan()
    try:
        if reindex:
            st.start(titles[0])
            r = cmd_build(rewrite=True, relabel=True)
            if r.get("relabeled"):
                say(f"Метки пересчитаны у {r['relabeled']} релизов, копия прежнего файла: data/{r['backup']}")
        dataset_stats()
        if do_prepare:
            st.start("prepare_data: data/labels.csv → data/processed")
            if not retrain.prepare():
                say("prepare_data завершился с ошибкой")
                return
        if what == "2":
            st.start(train_title)
            if not retrain.train_models(profiles, folds):
                say("обучение основных моделей завершилось с ошибкой")
                return
        new = "models/segmenter_v2"
        st.start("Обучение сегментатора (models/segmenter_v2)")
        if not retrain.train_segmenter(new):
            say("обучение сегментатора завершилось с ошибкой")
            return
        st.start("Тесты проекта")
        tests_ok = retrain.run_tests()
        dirs = (["models/segmenter"] if (ROOT / "models" / "segmenter").exists() else []) + [new]
        st.start("Сравнение по трекерам (правила / старые веса / новые)")
        try:
            results = retrain.compare(dirs)
        except RuntimeError as exc:
            say(str(exc))
            return
        st.finish()
        if len(dirs) == 2:
            better, why = retrain.verdict(results, dirs[0], dirs[1])
            say(f"\nНовые веса {'лучше' if better else 'НЕ лучше'} старых: {why}")
            say(f"Тесты проекта: {'ok' if tests_ok else 'ЕСТЬ ПАДЕНИЯ'}")
            default = "y" if better and tests_ok else "n"
        else:
            default = "y"
    finally:
        st.summary()
    if ask("Заменить models/segmenter новыми весами? (y/N)", default).lower() == "y":
        archive = retrain.promote(new)
        say(f"Готово. Старые веса: models/{archive}" if archive else "Готово.")
    else:
        say(f"Оставлено как есть. Новые веса: {new}")
    if what == "2":
        say("\nТеперь выберите основную модель.")
        wizard_models()


def _pct(x: float | None) -> str:
    return "—" if x is None else f"{x * 100:.1f}"


def wizard_models() -> None:
    """Пункт 7: сравнить все модели на ОДНОЙ текущей тестовой выборке и выбрать, какая станет models/best."""
    import retrain
    from src import runs
    if not runs.candidates():
        say("Нет обученных моделей в models/.")
        return
    if not runs.DATASET.exists():
        say("Нет data/processed/dataset.json: сначала prepare_data (пункт 2).")
        return
    say("Все модели оцениваются заново на текущих тестовых строках (в том входном формате, на котором они "
        "обучены), поэтому цифры сравнимы. Результат кэшируется.\n")
    while True:
        data = retrain.evaluate_models(MODELS_TMP)
        if not data:
            say("оценка не удалась")
            return
        items = data["items"]
        rows = []
        for i, it in enumerate(items, 1):
            m, lo, hi = it["metrics"], it["ci"][0], it["ci"][1]
            tag = (it["name"] + (f" ({it['profile']})" if it["profile"] and it["profile"] != it["name"] else "")
                   + (" *" if it.get("leak_risk") else ""))
            rows.append([i, tag, it["backbone"].split("/")[-1], it["mb"],
                         f"{_pct(m['joint_exact'])} [{_pct(lo)}–{_pct(hi)}]",
                         _pct(m["type_macro_f1"]), _pct(m["span_exact"]), _pct(m.get("age_f1")),
                         _pct(m.get("lang_accuracy")), runs.verdict(it)])
        ui.console.print(ui.summary_table(
            f"Тестовая выборка: {data['n']} строк (отпечаток {data['fingerprint']}); числа в %",
            ["№", "модель", "основа", "МБ", "joint exact [95%]", "type F1", "span", "18+ F1", "язык",
             "против models/best"], rows))
        base = next((it for it in items if it["name"] == "best"), None)
        good = [(it["metrics"]["joint_exact"], i) for i, it in enumerate(items, 1)
                if it.get("vs") and it["vs"]["p"] <= 0.05 and it["vs"]["fixed"] > it["vs"]["broken"]]
        if good:
            say(f"Рекомендую №{max(good)[1]}: значимо лучше текущей на тех же строках.")
        else:
            say("Ни одна модель не лучше текущей значимо — менять best нет оснований."
                if base else "models/best нет: выберите любую.")
        if any(it.get("leak_risk") for it in items):
            say("* модель обучена на другом разбиении данных: часть текущих тестовых строк она могла видеть "
                "при обучении, её цифры завышены, и новая модель сравнивается с ней в невыгодных условиях.")
        say("joint exact — строка распознана целиком (тип + автор + 18+). Разница в пределах доверительного "
            "интервала — это шум теста, а не улучшение.")
        raw = ask("№ модели для models/best (dN — удалить запуск, r — пересчитать, Enter — выйти)", "").lower()
        if not raw:
            return
        if raw == "r":
            retrain.evaluate_models(MODELS_TMP, refresh=True)
            continue
        delete = raw.startswith("d")
        try:
            it = items[int(raw.lstrip("d")) - 1]
        except (ValueError, IndexError):
            say("нет такого номера")
            continue
        if delete:
            if not runs.deletable(it["dir"]):
                say("Удалять можно только запуски (models/runs) и best_backup_*.")
            elif ask(f"Удалить {it['dir']} ({it['mb']} МБ)? (y/N)", "n").lower() == "y":
                runs.delete(it["dir"])
                say("удалено")
            continue
        if it["name"] == "best":
            say("Это и есть текущая models/best.")
            continue
        for w in runs.warnings_for(it["dir"]):
            say("⚠ " + w)
        if ask(f"Сделать {it['name']} моделью models/best? Прежняя уйдёт в models/best_backup_* (y/N)",
               "n").lower() == "y":
            archive = runs.promote(it["dir"])
            say(f"Готово. Прежняя модель: models/{archive}. Перезапустите сервис, чтобы он взял новую."
                if archive else "Готово.")


def banner_lines() -> list[str]:
    rows = coverage_rows()
    labeled = sum(r["labeled"] for r in rows)
    pages = sum(r["pages"] for r in rows)
    models = [d for d in ("best", "segmenter", "segmenter_v2") if (ROOT / "models" / d).exists()]
    cfg = settings()
    return [f"Размечено релизов: {labeled}   страниц: {pages}   meta: {sum(r['meta'] for r in rows)}",
            f"Модели в models/: {', '.join(models) or 'нет'}",
            f"Сбор: вкладок на трекер {cfg['tabs']}   пауза {cfg['delay']} с   лимит {cfg['limit']}",
            f"Chrome: порт {hv.CHROME_PORT}   профиль: {hv.CHROME_PROFILE}"]


def settings_screen() -> None:
    """Пункт «Настройки»: число вкладок (потоков) на трекер и параметры сбора."""
    cfg = settings()
    ui.console.print("[bold]Настройки сбора[/bold] [dim](Enter — оставить текущее)[/dim]\n")
    ui.console.print("Вкладок на трекер — сколько страниц качается одновременно. "
                     "[dim]1 — медленно и безопасно; 3–4 — в 2–3 раза быстрее, но чаще лимиты и Cloudflare.[/dim]")
    cfg["tabs"] = clamp_tabs(ask("Вкладок на трекер (1–4)", str(cfg["tabs"])))
    cfg["delay"] = float(ask("Пауза между раздачами на одну вкладку, с", str(cfg["delay"])))
    cfg["limit"] = int(ask("Лимит страниц на трекер за запуск", str(cfg["limit"])))
    ui.console.print("\nРежим выборки: [bold]balanced[/bold] — страницы вразброс по всему разделу, в каждой "
                     "берутся темы из недопредставленных годов и качеств; [bold]sequential[/bold] — подряд "
                     "от новых к старым.")
    cfg["mode"] = "sequential" if ask("Режим (balanced / sequential)", cfg["mode"]).lower().startswith("s") else "balanced"
    cfg["per_page"] = max(1, int(ask("Раздач с одной страницы списка (режим balanced)", str(cfg["per_page"]))))
    cfg["pages"] = int(ask("Страниц списка на раздел (режим sequential)", str(cfg["pages"])))
    cfg["workers"] = max(0, int(ask("Процессов для переиндексации (0 — авто: ядра минус 2)", str(cfg["workers"]))))
    save_settings(cfg)
    say(f"Сохранено: вкладок {cfg['tabs']}, пауза {cfg['delay']} с, лимит {cfg['limit']}, "
        f"режим {cfg['mode']}, раздач со страницы {cfg['per_page']}, страниц списка {cfg['pages']}")


def menu() -> None:
    while True:
        ui.clear()
        ui.console.print(ui.banner(banner_lines()))
        ui.console.print(ui.menu_table([
            ("1", "Собрать датасет  [dim](окна → вход → поиск разделов → сбор → pages/labels/meta)[/dim]"),
            ("2", "Переобучить и протестировать  [dim](обучение → тесты → сравнение → подмена весов)[/dim]"),
            ("3", "Статистика датасета  [dim](по трекерам: тип, качество, годы, языки)[/dim]"),
            ("4", "Дополнительно  [dim](отдельные шаги сбора, импорт, поиск разделов)[/dim]"),
            ("5", "Настройки  [dim](вкладок на трекер, пауза, лимиты)[/dim]"),
            ("6", "Обучение по ссылкам  [dim](добавить раздачи вручную, поправить метки, переобучить)[/dim]"),
            ("7", "Модели  [dim](сравнить обученные на одной выборке, выбрать лучшую, откатиться)[/dim]"),
            ("0", "Выход")]))
        choice = ask("Пункт", "").lower()
        if choice in ("0", "q", ""):
            return
        ui.clear()                                   # чистый экран под выбранный режим
        try:
            if choice == "1":
                wizard_collect()
            elif choice == "2":
                wizard_retrain()
            elif choice == "3":
                cmd_status()
            elif choice == "4":
                advanced_menu()
                continue
            elif choice == "5":
                settings_screen()
            elif choice == "6":
                wizard_links()
            elif choice == "7":
                wizard_models()
            else:
                continue
        except KeyboardInterrupt:
            say("\nпрервано")
        except Exception as exc:                                  # noqa: BLE001
            say(f"ошибка: {exc}")
        ui.pause()                                   # дать прочитать результат до очистки


def advanced_menu() -> None:
    stop = threading.Event()
    while True:
        ui.clear()
        ui.console.print(ui.menu_table([
            ("1", "Открыть окна браузера и войти в аккаунты"),
            ("2", "Собрать новые раздачи из списков"),
            ("3", "Дособрать страницы для уже размеченных раздач"),
            ("4", "Собрать data/pages, data/labels.csv и data/meta.csv из data/raw"),
            ("5", "Импортировать старый harvest [dim](быстро, без браузера)[/dim]"),
            ("6", "Статус"),
            ("7", "Найти разделы с зарубежными фильмами и сериалами заново"),
            ("0", "Назад")]))
        choice = ask("Пункт", "").lower()
        if choice in ("0", "q", ""):
            return
        ui.clear()
        stop.clear()
        try:
            if choice == "1":
                cmd_windows(ask_sites())
            elif choice == "2":
                sites = ask_sites()
                pages = int(ask("Страниц списка на раздел", "2"))
                limit = int(ask("Максимум раздач на трекер", "50"))
                delay = float(ask("Пауза между раздачами, с", "2"))
                jobs = {}
                for s in sites:
                    refs = ask(f"{s}: {SITES[s]['what']}", SITES[s]["refs"])
                    jobs[s] = safe(s, lambda s=s, refs=refs: run_collect(
                        s, [r.strip() for r in refs.split(",") if r.strip()],
                        pages, limit, delay, stop))
                run_threads(jobs, stop)
            elif choice == "3":
                sites = ask_sites("kinozal,nnm")
                limit = int(ask("Максимум страниц на трекер", "100"))
                delay = float(ask("Пауза между раздачами, с", "2"))
                run_threads({s: safe(s, lambda s=s: run_backfill(s, limit, delay, stop))
                             for s in sites}, stop)
            elif choice == "4":
                cmd_build(ask("Пересобрать всё заново, игнорируя кэш? (y/N)", "n").lower() == "y")
            elif choice == "5":
                default = os.environ.get("DUB_LEGACY_DIR", "")
                cmd_import_legacy(ask("Каталог старого harvest (содержит raw/*.jsonl)", default))
            elif choice == "6":
                cmd_status()
            elif choice == "7":
                ensure_sections(ask_sites(), force=True)
            else:
                continue
        except KeyboardInterrupt:
            say("\nпрервано")
        except Exception as exc:                                  # noqa: BLE001
            say(f"ошибка: {exc}")
        ui.pause()


def main() -> int:
    try:
        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
    except (AttributeError, ValueError):
        pass
    os.environ["DUB_TABS"] = str(settings()["tabs"])        # число вкладок из сохранённых настроек
    ap = argparse.ArgumentParser(description=__doc__,
                                 formatter_class=argparse.RawDescriptionHelpFormatter)
    sub = ap.add_subparsers(dest="cmd")
    p = sub.add_parser("windows")
    p.add_argument("--sites", default=",".join(SITES))
    p = sub.add_parser("collect")
    p.add_argument("--site", required=True, choices=list(SITES))
    p.add_argument("--refs", help="разделы/адреса списков через запятую")
    p.add_argument("--pages", type=int, default=2)
    p.add_argument("--limit", type=int, default=50)
    p.add_argument("--delay", type=float, default=2.0)
    p.add_argument("--from-page", type=int)
    p.add_argument("--tabs", type=int, default=3, help="вкладок на трекер (параллельно)")
    p = sub.add_parser("backfill")
    p.add_argument("--site", required=True, choices=list(SITES))
    p.add_argument("--limit", type=int, default=100)
    p.add_argument("--delay", type=float, default=2.0)
    p.add_argument("--tabs", type=int, default=3, help="вкладок на трекер (параллельно)")
    p = sub.add_parser("repair-html", help="сделать старые сохранённые страницы читаемыми (UTF-8, стили)")
    p.add_argument("--no-css", action="store_true", help="только кодировка и адрес, без браузера")
    p = sub.add_parser("build")
    p.add_argument("--rewrite", action="store_true")
    p.add_argument("--relabel", action="store_true",
                   help="пересчитать метки размеченных релизов из сохранённого HTML (с бэкапом labels.csv)")
    p = sub.add_parser("import-legacy")
    p.add_argument("--dir", required=True)
    sub.add_parser("status")
    sub.add_parser("meta")
    p = sub.add_parser("discover")
    p.add_argument("--sites", default=",".join(SITES))
    p.add_argument("--force", action="store_true", help="искать заново, игнорируя кэш")
    args = ap.parse_args()

    stop = threading.Event()
    if args.cmd is None:
        menu()
    elif args.cmd == "discover":
        ensure_sections([s for s in args.sites.split(",") if s in SITES], args.force)
    elif args.cmd == "windows":
        cmd_windows([s for s in args.sites.split(",") if s in SITES])
    elif args.cmd in ("collect", "backfill") and args.tabs:
        os.environ["DUB_TABS"] = str(args.tabs)
    if args.cmd == "collect":
        found = ",".join(section_refs(args.site))
        refs = [r.strip() for r in (args.refs or found or SITES[args.site]["refs"]).split(",")
                if r.strip()]
        run_threads({args.site: safe(args.site, lambda: run_collect(
            args.site, refs, args.pages, args.limit, args.delay, stop, args.from_page))}, stop)
    elif args.cmd == "backfill":
        run_threads({args.site: safe(args.site, lambda: run_backfill(
            args.site, args.limit, args.delay, stop))}, stop)
    elif args.cmd == "repair-html":
        cmd_repair_html(not args.no_css)
    elif args.cmd == "build":
        cmd_build(args.rewrite, args.relabel)
    elif args.cmd == "import-legacy":
        cmd_import_legacy(args.dir)
    elif args.cmd == "status":
        cmd_status()
    elif args.cmd == "meta":
        say(f"meta: {cmd_meta()['rows']} строк -> {META.relative_to(ROOT)}")
    return 0


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