from __future__ import annotations

import argparse
import json
import random
from collections import Counter
from dataclasses import asdict
from pathlib import Path
from typing import Any

import numpy as np
from tqdm import tqdm

from kawk50m.cli import configure_utf8_stdio
from kawk50m.io import discover_paths, iter_documents
from kawk50m.text import (
    FilterConfig,
    measure_text,
    quality_score,
    rejection_reason,
)


METRIC_FIELDS = (
    "characters",
    "hangul_visible_ratio",
    "hangul_letter_ratio",
    "digit_ratio",
    "symbol_ratio",
    "unique_line_ratio",
    "unique_word_ratio",
    "short_line_ratio",
    "list_line_ratio",
    "table_line_ratio",
    "boilerplate_hits_per_1k",
    "repeated_character_run",
)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Audit Korean corpus quality and write deterministic samples."
    )
    parser.add_argument("--input", nargs="+", required=True)
    parser.add_argument("--output-dir", required=True)
    parser.add_argument("--limit", type=int, default=100_000)
    parser.add_argument("--sample-size", type=int, default=200)
    parser.add_argument("--lowest-quality-size", type=int, default=200)
    parser.add_argument("--seed", type=int, default=42)
    return parser.parse_args()


def quantiles(values: list[float]) -> dict[str, float]:
    if not values:
        return {}
    result = np.quantile(
        np.asarray(values, dtype=np.float64),
        [0.0, 0.01, 0.05, 0.25, 0.50, 0.75, 0.95, 0.99, 1.0],
    )
    names = ("min", "p01", "p05", "p25", "p50", "p75", "p95", "p99", "max")
    return {name: float(value) for name, value in zip(names, result)}


def compact_row(
    document: dict[str, Any],
    *,
    score: float,
    reason: str | None,
    metrics: Any,
) -> dict[str, Any]:
    return {
        "id": document.get("id"),
        "source": document.get("source"),
        "url": document.get("url"),
        "quality_score": round(score, 6),
        "rejection_reason": reason,
        "metrics": {
            field: getattr(metrics, field)
            for field in METRIC_FIELDS
        },
        "text": document["text"],
    }


def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
    with path.open("w", encoding="utf-8") as handle:
        for row in rows:
            handle.write(json.dumps(row, ensure_ascii=False) + "\n")


def main() -> None:
    configure_utf8_stdio()
    args = parse_args()
    if args.limit <= 0:
        raise ValueError("--limit must be positive")
    if args.sample_size < 0 or args.lowest_quality_size < 0:
        raise ValueError("sample sizes must be non-negative")

    paths = discover_paths(args.input)
    if not paths:
        raise FileNotFoundError("No supported audit inputs were found")

    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)
    expected_outputs = (
        output_dir / "audit_summary.json",
        output_dir / "random_sample.jsonl",
        output_dir / "lowest_quality.jsonl",
    )
    for path in expected_outputs:
        if path.exists():
            raise FileExistsError(
                f"{path} already exists. Choose a new audit output directory."
            )

    rng = random.Random(args.seed)
    filter_config = FilterConfig()
    counters: Counter[str] = Counter()
    sources: Counter[str] = Counter()
    values: dict[str, list[float]] = {
        field: [] for field in (*METRIC_FIELDS, "quality_score")
    }
    sample: list[dict[str, Any]] = []
    lowest: list[dict[str, Any]] = []

    documents = iter_documents(paths)
    for index, document in enumerate(
        tqdm(documents, total=args.limit, unit="docs"),
        start=1,
    ):
        if index > args.limit:
            break
        metrics = measure_text(document["text"])
        reason = rejection_reason(
            document["text"], filter_config, metrics=metrics
        )
        score = quality_score(metrics, filter_config)
        row = compact_row(
            document,
            score=score,
            reason=reason,
            metrics=metrics,
        )

        counters["documents"] += 1
        counters["accepted" if reason is None else f"rejected_{reason}"] += 1
        sources[str(document.get("source") or "unknown")] += 1
        for field in METRIC_FIELDS:
            values[field].append(float(getattr(metrics, field)))
        values["quality_score"].append(score)

        if len(sample) < args.sample_size:
            sample.append(row)
        elif args.sample_size:
            replacement = rng.randrange(index)
            if replacement < args.sample_size:
                sample[replacement] = row

        if args.lowest_quality_size:
            lowest.append(row)
            lowest.sort(key=lambda item: item["quality_score"])
            if len(lowest) > args.lowest_quality_size:
                lowest.pop()

    summary = {
        "inputs": [str(path) for path in paths],
        "limit": args.limit,
        "seed": args.seed,
        "filter": asdict(filter_config),
        "counts": dict(sorted(counters.items())),
        "sources": dict(sources.most_common()),
        "quantiles": {
            field: quantiles(field_values)
            for field, field_values in values.items()
        },
    }

    with (output_dir / "audit_summary.json").open(
        "w", encoding="utf-8"
    ) as handle:
        json.dump(summary, handle, ensure_ascii=False, indent=2)
        handle.write("\n")
    write_jsonl(output_dir / "random_sample.jsonl", sample)
    write_jsonl(output_dir / "lowest_quality.jsonl", lowest)
    print(json.dumps(summary, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()