"""ノイズ除去の第2パス（監査項目14〜21）。

第1パス（``run_shard.py``: 有害フィルタ → PII 置換）のクリーン済み出力
``<input-dir>/<shard>/<shard>.parquet`` を入力にし、``<output-root>/<shard>/`` に
``<shard>.parquet``（ノイズ除去後）、``noise/removed.jsonl``、``noise/summary.json``、
``noise_summary.json`` を書く。``--upload-repo`` を付けると HF データセットへ
バッチアップロードしてローカルを削除する（HF Jobs の一時ディスク対策）。

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

トークン数の閾値を使う場合は ``--tokenizer <HFモデル名>`` と ``--min-tokens/--max-tokens`` を指定する
（transformers が必要。既定は文字数のみ）。
"""

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

from run_shard import Uploader, stage_input


NOISE_PASS_VERSION = "abeja-cc-ja-noise-pass/2026-09-04"
_WORKER: dict[str, Any] = {}


def _init_worker(config: dict[str, Any]) -> None:
    import sys

    sys.path.insert(0, str(Path(__file__).resolve().parent))
    from filter_noise import NoiseFilter

    _WORKER["config"] = config
    _WORKER["filter"] = NoiseFilter(
        Path(config["patterns_dir"]),
        min_chars=config["min_chars"], max_chars=config["max_chars"], newline_policy=config["newline_policy"],
        tokenizer=config.get("tokenizer"), min_tokens=config.get("min_tokens"), max_tokens=config.get("max_tokens"),
    )


def process_shard(input_path: Path, output_root: Path, config: dict[str, Any]) -> dict[str, Any]:
    from filter_noise import run_noise_filter

    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
    summary = run_noise_filter(input_path, out_dir / "noise", _WORKER["filter"], batch_size=config["batch_size"], output_name="cleaned.parquet")
    final_path = out_dir / f"{shard}.parquet"
    shutil.move(str(out_dir / "noise" / "cleaned.parquet"), str(final_path))
    shard_summary = {
        "pipeline_version": NOISE_PASS_VERSION,
        "stage": "noise",
        "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": round(time.perf_counter() - started, 1),
        "noise": {
            "thresholds": summary["thresholds"],
            "records_scanned": summary["records_scanned"],
            "records_deleted": summary["records_deleted"],
            "records_retained": summary["records_retained"],
            "records_modified": summary["records_modified"],
            "records_newline_joined": summary["records_newline_joined"],
            "records_deleted_by_reason": summary["records_deleted_by_reason"],
            "chars_before": summary["chars_before"],
            "chars_after_retained": summary["chars_after_retained"],
            "tokens_after_retained": summary["tokens_after_retained"],
            "by_item": summary["by_item"],
            "patterns": [
                {k: p[k] for k in ("id", "item", "action", "records_detected", "occurrences", "lines_removed", "replacements")}
                for p in summary["patterns"]
            ],
        },
        "output": {"cleaned_parquet": str(final_path), "final_rows": summary["records_retained"], "removed_jsonl": str(out_dir / "noise" / "removed.jsonl")},
    }
    (out_dir / "noise_summary.json").write_text(json.dumps(shard_summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    return shard_summary


def _worker_entry(args: tuple[str, str, dict[str, Any]]) -> dict[str, Any]:
    input_path, output_root, config = args
    staging_dir = Path(config["staging_dir"]) if config.get("staging_dir") else None
    local_input: Path | None = None
    last_error: Exception | None = None
    for attempt in range(1, 4):
        try:
            local_input = stage_input(Path(input_path), staging_dir)
            # 有害フィルタの removed.jsonl は元のディレクトリから読むため、入力の場所を config で渡す
            result = process_shard(local_input, Path(output_root), {**config, "source_dir": str(Path(input_path).parent)})
            result["input_file"] = input_path
            return result
        except OSError as error:
            last_error = error
            print(json.dumps({"event": "io_retry", "shard": Path(input_path).stem, "attempt": attempt, "error": repr(error)[:160]}), flush=True)
            time.sleep(30 * attempt)
        except Exception as error:  # noqa: BLE001
            return {"shard": Path(input_path).stem, "input_file": input_path, "error": repr(error), "traceback": traceback.format_exc()}
        finally:
            if local_input is not None and staging_dir is not None and local_input != Path(input_path):
                local_input.unlink(missing_ok=True)
    return {"shard": Path(input_path).stem, "input_file": input_path, "error": repr(last_error), "traceback": ""}


def discover_inputs(input_dir: Path) -> list[Path]:
    """``<dir>/<shard>/<shard>.parquet``（第1パス出力）か ``<dir>/*.parquet`` を列挙する。"""

    nested = sorted(p for p in input_dir.glob("*/*.parquet") if p.stem == p.parent.name)
    return nested or sorted(input_dir.glob("*.parquet"))


def main(argv: list[str] | None = None) -> None:
    source_dir = Path(__file__).resolve().parent
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("--input-dir", type=Path, required=True)
    parser.add_argument("--output-root", type=Path, required=True)
    parser.add_argument("--limit-shards", type=int, default=None)
    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("--patterns-dir", type=Path, default=source_dir / "noise")
    parser.add_argument("--min-chars", type=int, default=200)
    parser.add_argument("--max-chars", type=int, default=100_000)
    parser.add_argument("--newline-policy", choices=("join", "delete", "keep"), default="join")
    parser.add_argument("--tokenizer", default=None, help="トークン数を数える HF トークナイザ名（任意）")
    parser.add_argument("--min-tokens", type=int, default=None)
    parser.add_argument("--max-tokens", type=int, default=None)
    parser.add_argument("--upload-repo", default=None)
    parser.add_argument("--upload-prefix", default="outputs_v2")
    parser.add_argument("--upload-batch", type=int, default=5)
    parser.add_argument("--delete-local-after-upload", action="store_true")
    parser.add_argument("--skip-existing-in-repo", action="store_true")
    parser.add_argument("--staging-dir", type=Path, default=None, help="入力parquetを処理前にコピーするローカルディレクトリ（マウントの I/O エラー対策）")
    args = parser.parse_args(argv)

    inputs = discover_inputs(args.input_dir)
    if args.limit_shards is not None:
        inputs = inputs[: args.limit_shards]
    if not inputs:
        raise FileNotFoundError(f"入力parquetが見つかりません: {args.input_dir}")
    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(marker="noise_summary.json")
    todo = []
    for path in inputs:
        if path.stem in skip or (args.output_root / path.stem / "noise_summary.json").exists():
            print(json.dumps({"event": "skip", "shard": path.stem}), flush=True)
            continue
        todo.append(path)
    config = {
        "patterns_dir": str(args.patterns_dir), "batch_size": args.batch_size,
        "min_chars": args.min_chars, "max_chars": args.max_chars, "newline_policy": args.newline_policy,
        "tokenizer": args.tokenizer, "min_tokens": args.min_tokens, "max_tokens": args.max_tokens,
        "staging_dir": str(args.staging_dir) if args.staging_dir else None,
    }
    print(json.dumps({"event": "start", "stage": "noise", "shards": len(todo), "skipped": len(inputs) - len(todo), "workers": args.workers, "thresholds": config}, ensure_ascii=False), flush=True)
    jobs = [(str(p), str(args.output_root), config) for p in todo]
    if args.workers <= 1 or len(jobs) <= 1:
        _init_worker(config)
        iterator = map(_worker_entry, jobs)
    else:
        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)
    results: list[dict[str, Any]] = []
    run_started = time.perf_counter()
    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"],
            "noise_deleted": result["noise"]["records_deleted"], "modified": result["noise"]["records_modified"],
            "final_rows": result["output"]["final_rows"], "seconds": result["seconds"],
        }), 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": NOISE_PASS_VERSION, "stage": "noise",
        "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_noise_{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()