"""シャード単位のクレンジングパイプライン（本実行用）。

1ファイル（parquet）ごとに次を行う。

1. 有害コンテンツフィルタ（ワードリスト・ドメインブロックリスト・近接共起規則）
2. 保持分に PII 置換
3. クリーン済み parquet と監査ファイル（removed.jsonl, audit.jsonl 等）を
   ``<output-root>/<シャード名>/`` に書き出し、``shard_summary.json`` にまとめる
4. 任意で HF データセットへバッチアップロード（``--upload-repo``）。アップロード後に
   ローカルを削除すれば、HF Jobs の一時ディスク（50 GB）でも全シャードを処理できる

``--workers`` でシャード並列に処理する。各ワーカーはワードリスト・ブロックリスト・
共起規則を1回だけ読み込む（UT1 adult リストで約1.6 GB/ワーカー）。
``shard_summary.json`` が既にあるシャードと、``--skip-existing-in-repo`` で
リポジトリに既に出力があるシャードは飛ばすので、途中終了後の再実行ができる。

    uv run python abeja-cc-ja/src/run_shard.py --input-dir <dir> --output-root <out> --workers 7 \\
        --upload-repo Podtech/abeja-cc-ja-cleaned --upload-prefix outputs/common_crawl_0 --delete-local-after-upload
"""

from __future__ import annotations

import argparse
import json
import multiprocessing as mp
import os
import shutil
import time
import traceback
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

import pyarrow.parquet as pq


PIPELINE_VERSION = "abeja-cc-ja-cleansing/2026-09-04"
MODE = "distinct_terms_3plus"

_WORKER: dict[str, Any] = {}


def _init_worker(config: dict[str, Any]) -> None:
    """ワーカー起動時にリソースを1回だけ読み込む。"""

    import sys

    sys.path.insert(0, str(Path(__file__).resolve().parent))
    from cooccurrence import CooccurrenceDetector, load_rules
    from domain_blocklist import DomainBlocklist

    _WORKER["config"] = config
    _WORKER["blocklist"] = None if config["no_blocklist"] else DomainBlocklist.load(Path(config["blocklist_dir"]), Path(config["blocklist_cache_dir"]))
    _WORKER["cooccurrence"] = None if config["no_cooccurrence"] else CooccurrenceDetector(load_rules(Path(config["cooccurrence_rules"])))


def process_shard(input_path: Path, output_root: Path, config: dict[str, Any]) -> dict[str, Any]:
    """1シャードを処理し、shard_summary を返す（ワーカー内で実行）。"""

    from filter_pii import run_filter as run_pii
    from filter_toxic import run_toxic_filters

    if not _WORKER:
        _init_worker(config)
    shard = input_path.stem
    out_dir = output_root / shard
    out_dir.mkdir(parents=True, exist_ok=True)
    started = time.perf_counter()
    started_at = datetime.now(timezone.utc).isoformat()
    input_rows = pq.ParquetFile(input_path).metadata.num_rows

    t0 = time.perf_counter()
    toxic = run_toxic_filters(
        input_path=input_path,
        output_root=out_dir / "toxic",
        reference_dir=Path(config["reference_dir"]),
        additional_dir=Path(config["additional_dir"]),
        batch_size=config["batch_size"],
        modes=[MODE],
        exclude_dir=Path(config["exclude_dir"]),
        blocklist=_WORKER["blocklist"],
        cooccurrence=_WORKER["cooccurrence"],
    )
    toxic_seconds = time.perf_counter() - t0
    toxic_mode = toxic["modes"][MODE]
    retained_path = out_dir / "toxic" / MODE / "retained.parquet"

    t0 = time.perf_counter()
    pii = run_pii(
        input_path=retained_path,
        output_root=out_dir / "pii",
        batch_size=config["batch_size"],
        policy_approver=config.get("policy_approver"),
        policy_approved_on=config.get("policy_approved_on"),
        policy_note=config.get("policy_note"),
    )
    pii_seconds = time.perf_counter() - t0

    final_path = out_dir / f"{shard}.parquet"
    shutil.move(str(out_dir / "pii" / "pii_replaced" / "replaced.parquet"), str(final_path))
    if not config.get("keep_intermediate"):
        retained_path.unlink(missing_ok=True)
    final_rows = pq.ParquetFile(final_path).metadata.num_rows

    summary = {
        "pipeline_version": PIPELINE_VERSION,
        "shard": shard,
        "input_file": str(input_path),
        "input_rows": input_rows,
        "started_at_utc": started_at,
        "finished_at_utc": datetime.now(timezone.utc).isoformat(),
        "seconds": {"toxic": round(toxic_seconds, 1), "pii": round(pii_seconds, 1), "total": round(time.perf_counter() - started, 1)},
        "toxic": {
            "mode": MODE,
            "threshold": toxic_mode["threshold"],
            "category_thresholds": toxic_mode.get("category_thresholds", {}),
            "records_scanned": toxic_mode["total_records_scanned"],
            "records_deleted": toxic_mode["records_deleted"],
            "records_retained": toxic_mode["records_retained"],
            "records_deleted_by_reason": toxic_mode["records_deleted_by_reason"],
            "by_category": {c: {"records_with_match": v["records_with_match"], "records_deleted": v["records_deleted"]} for c, v in toxic_mode["by_category"].items()},
            "domain_blocklist_by_source": {k: v for k, v in toxic_mode.get("domain_blocklist", {}).get("by_source", {}).items()},
            "domain_blocklist_sources": toxic_mode.get("domain_blocklist", {}).get("sources"),
            "cooccurrence_by_rule": {k: {"records_matched": v["records_matched"]} for k, v in toxic_mode.get("cooccurrence", {}).get("by_rule", {}).items()},
            "wordlist_excluded_terms_by_category": toxic_mode.get("wordlist_excluded_terms_by_category"),
            "wordlist_unique_terms_by_category": toxic.get("wordlist_unique_terms_by_category"),
        },
        "pii": {
            "records_scanned": pii["total_records_scanned"],
            "records_with_replacement": pii["records_with_replacement"],
            "total_replacements": pii["total_replacements"],
            "by_type": {k: {"records_with_match": v["records_with_match"], "replacement_count": v["replacement_count"]} for k, v in pii["by_type"].items()},
            "policy": pii["pii_policy"],
            "detector_version": pii.get("detector_version"),
        },
        "output": {
            "cleaned_parquet": str(final_path),
            "final_rows": final_rows,
            "removed_jsonl": str(out_dir / "toxic" / MODE / "removed.jsonl"),
            "cooccurrence_review_jsonl": str(out_dir / "toxic" / MODE / "cooccurrence_review.jsonl"),
            "flagged_jsonl": str(out_dir / "toxic" / MODE / "flagged.jsonl"),
            "borderline_jsonl": str(out_dir / "toxic" / MODE / "borderline.jsonl"),
            "pii_audit_jsonl": str(out_dir / "pii" / "pii_replaced" / "audit.jsonl"),
        },
    }
    (out_dir / "shard_summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    return summary


def _worker_entry(args: tuple[str, str, dict[str, Any]]) -> dict[str, Any]:
    input_path, output_root, config = args
    try:
        return process_shard(Path(input_path), Path(output_root), config)
    except Exception as error:  # noqa: BLE001 - 1シャードの失敗で全体を止めない
        return {"shard": Path(input_path).stem, "input_file": input_path, "error": repr(error), "traceback": traceback.format_exc()}


class Uploader:
    """完了したシャードのディレクトリをまとめて HF データセットへアップロードする。"""

    def __init__(self, repo_id: str, prefix: str, output_root: Path, batch: int, delete_local: bool, private: bool = True) -> None:
        from huggingface_hub import HfApi

        self.api = HfApi()
        self.repo_id = repo_id
        self.prefix = prefix.strip("/")
        self.output_root = output_root
        self.batch = max(1, batch)
        self.delete_local = delete_local
        self.pending: list[str] = []
        self.uploaded: list[str] = []
        self.api.create_repo(repo_id, repo_type="dataset", private=private, exist_ok=True)

    def existing_shards(self) -> set[str]:
        files = self.api.list_repo_files(self.repo_id, repo_type="dataset")
        marker = f"{self.prefix}/"
        return {path[len(marker):].split("/", 1)[0] for path in files if path.startswith(marker) and path.endswith("/shard_summary.json")}

    def add(self, shard: str) -> None:
        self.pending.append(shard)
        if len(self.pending) >= self.batch:
            self.flush()

    def flush(self) -> None:
        if not self.pending:
            return
        shards = list(self.pending)
        for attempt in range(5):
            try:
                self.api.upload_folder(
                    repo_id=self.repo_id,
                    repo_type="dataset",
                    folder_path=str(self.output_root),
                    path_in_repo=self.prefix,
                    allow_patterns=[f"{shard}/**" for shard in shards],
                    commit_message=f"add {len(shards)} shard(s): {shards[0]}..{shards[-1]}",
                )
                break
            except Exception as error:  # noqa: BLE001
                wait = 30 * (attempt + 1)
                print(json.dumps({"event": "upload_retry", "attempt": attempt + 1, "error": repr(error), "wait_s": wait}), flush=True)
                time.sleep(wait)
        else:
            raise RuntimeError(f"アップロードに失敗しました: {shards}")
        self.uploaded.extend(shards)
        self.pending.clear()
        print(json.dumps({"event": "uploaded", "shards": shards, "repo": self.repo_id, "prefix": self.prefix}), flush=True)
        if self.delete_local:
            for shard in shards:
                shutil.rmtree(self.output_root / shard, ignore_errors=True)


def main(argv: list[str] | None = None) -> None:
    source_dir = Path(__file__).resolve().parent
    project_root = source_dir.parent
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    group = parser.add_mutually_exclusive_group(required=True)
    group.add_argument("--input", type=Path, action="append", help="入力parquet（複数可）")
    group.add_argument("--input-dir", type=Path, help="入力parquetのディレクトリ")
    parser.add_argument("--pattern", default="*.parquet")
    parser.add_argument("--limit-shards", type=int, default=None, help="先頭N件だけ処理する（試運転用）")
    parser.add_argument("--output-root", type=Path, required=True)
    parser.add_argument("--workers", type=int, default=max(1, (os.cpu_count() or 2) - 1))
    parser.add_argument("--batch-size", type=int, default=2048)
    parser.add_argument("--keep-intermediate", action="store_true", help="有害フィルタ後の retained.parquet を残す")
    parser.add_argument("--reference-dir", type=Path, default=source_dir / "wordlists" / "reference")
    parser.add_argument("--additional-dir", type=Path, default=source_dir / "wordlists")
    parser.add_argument("--exclude-dir", type=Path, default=source_dir / "wordlists" / "exclude")
    parser.add_argument("--blocklist-dir", type=Path, default=source_dir / "blocklists")
    parser.add_argument("--blocklist-cache-dir", type=Path, default=project_root / "data" / "blocklists" / "ut1")
    parser.add_argument("--no-blocklist", action="store_true")
    parser.add_argument("--cooccurrence-rules", type=Path, default=source_dir / "wordlists" / "cooccurrence" / "rules.json")
    parser.add_argument("--no-cooccurrence", action="store_true")
    parser.add_argument("--policy-approver", default=None)
    parser.add_argument("--policy-approved-on", default=None)
    parser.add_argument("--policy-note", default=None)
    parser.add_argument("--upload-repo", default=None, help="出力先の HF データセット（例: Podtech/abeja-cc-ja-cleaned）。非公開で作成する")
    parser.add_argument("--upload-prefix", default="outputs", help="リポジトリ内のパス接頭辞（例: outputs/common_crawl_0）")
    parser.add_argument("--upload-batch", type=int, default=5, help="何シャードごとに1コミットでアップロードするか")
    parser.add_argument("--delete-local-after-upload", action="store_true")
    parser.add_argument("--skip-existing-in-repo", action="store_true", help="リポジトリに shard_summary.json があるシャードを飛ばす")
    args = parser.parse_args(argv)

    if args.input_dir:
        inputs = sorted(args.input_dir.glob(args.pattern))
    else:
        inputs = list(args.input)
    if args.limit_shards is not None:
        inputs = inputs[: args.limit_shards]
    if not inputs:
        raise FileNotFoundError("入力parquetが見つかりません")
    args.output_root.mkdir(parents=True, exist_ok=True)

    uploader = None
    skip: set[str] = set()
    if args.upload_repo:
        uploader = Uploader(args.upload_repo, args.upload_prefix, args.output_root, args.upload_batch, args.delete_local_after_upload)
        if args.skip_existing_in_repo:
            skip = uploader.existing_shards()
    todo = []
    for path in inputs:
        shard = path.stem
        if shard in skip or (args.output_root / shard / "shard_summary.json").exists():
            print(json.dumps({"event": "skip", "shard": shard}), flush=True)
            continue
        todo.append(path)

    config = {
        "batch_size": args.batch_size,
        "keep_intermediate": args.keep_intermediate,
        "reference_dir": str(args.reference_dir), "additional_dir": str(args.additional_dir), "exclude_dir": str(args.exclude_dir),
        "blocklist_dir": str(args.blocklist_dir), "blocklist_cache_dir": str(args.blocklist_cache_dir), "no_blocklist": args.no_blocklist,
        "cooccurrence_rules": str(args.cooccurrence_rules), "no_cooccurrence": args.no_cooccurrence,
        "policy_approver": args.policy_approver, "policy_approved_on": args.policy_approved_on, "policy_note": args.policy_note,
    }
    run_started = time.perf_counter()
    results: list[dict[str, Any]] = []
    print(json.dumps({"event": "start", "shards": len(todo), "skipped": len(inputs) - len(todo), "workers": args.workers, "output_root": str(args.output_root)}), flush=True)
    jobs = [(str(path), str(args.output_root), config) for path in todo]
    if args.workers <= 1 or len(jobs) <= 1:
        _init_worker(config)
        iterator = map(_worker_entry, jobs)
    else:
        # pyarrow がスレッドを持つため fork は子プロセスのデッドロック要因になる。spawn で各ワーカーが独立に読み込む。
        context = mp.get_context("spawn")
        pool = context.Pool(processes=min(args.workers, len(jobs)), initializer=_init_worker, initargs=(config,))
        iterator = pool.imap_unordered(_worker_entry, jobs)
    for result in iterator:
        results.append(result)
        if "error" in result:
            print(json.dumps({"event": "error", "shard": result["shard"], "error": result["error"]}), flush=True)
            continue
        print(json.dumps({
            "event": "done", "shard": result["shard"], "input_rows": result["input_rows"],
            "toxic_deleted": result["toxic"]["records_deleted"], "pii_replacements": result["pii"]["total_replacements"],
            "final_rows": result["output"]["final_rows"], "seconds": result["seconds"]["total"],
        }, ensure_ascii=False), flush=True)
        if uploader is not None:
            uploader.add(result["shard"])
    if uploader is not None:
        uploader.flush()
    errors = [r for r in results if "error" in r]
    run_summary = {
        "pipeline_version": PIPELINE_VERSION,
        "finished_at_utc": datetime.now(timezone.utc).isoformat(),
        "shards_processed": len(results) - len(errors),
        "shards_failed": [{"shard": r["shard"], "error": r["error"]} for r in errors],
        "shards_skipped": len(inputs) - len(todo),
        "seconds": round(time.perf_counter() - run_started, 1),
        "upload_repo": args.upload_repo,
        "upload_prefix": args.upload_prefix if args.upload_repo else None,
    }
    (args.output_root / f"run_summary_{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ')}.json").write_text(json.dumps(run_summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    print(json.dumps({"event": "finish", **run_summary}, ensure_ascii=False), flush=True)
    if errors:
        raise SystemExit(1)


if __name__ == "__main__":
    main()