#!/usr/bin/env python3
"""Benchmark every tokenizer JSON row on one fixed Polish suite.

The benchmark is diagnostic, not a downstream-language-model quality score.
All tokenizers see exactly the same strings and are loaded from the lossless
``tokenizer_json`` column, so no contributor-specific files are required.
"""

from __future__ import annotations

import argparse
import hashlib
import importlib.metadata
import json
import platform
import re
import statistics
import time
from collections import Counter
from pathlib import Path

import pyarrow as pa
import pyarrow.parquet as pq
from tokenizers import Tokenizer

from custom_tokenizer_adapters import AdaptedTokenizer, load_custom_tokenizer_document


WORD_RE = re.compile(r"\w+", re.UNICODE)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser()
    parser.add_argument("--input", type=Path, default=Path("data/train-00000-of-00001.parquet"))
    parser.add_argument("--suite", type=Path, default=Path("evaluation/polish_suite.jsonl"))
    parser.add_argument("--output", type=Path, default=Path("results/tokenizer_benchmark.parquet"))
    parser.add_argument("--summary-json", type=Path, default=Path("results/tokenizer_benchmark.json"))
    parser.add_argument("--repeats", type=int, default=15, help="Timed batch repetitions")
    return parser.parse_args()


def load_suite(path: Path) -> list[dict[str, str]]:
    records = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
    if not records or any(set(record) != {"domain", "text"} for record in records):
        raise ValueError("suite must contain non-empty JSONL records with exactly domain and text")
    return records


def timed_median(function, repeats: int) -> float:
    samples = []
    for _ in range(repeats):
        start = time.perf_counter_ns()
        function()
        samples.append((time.perf_counter_ns() - start) / 1e9)
    return statistics.median(samples)


def encode_batch(tokenizer: Tokenizer | AdaptedTokenizer, texts: list[str]) -> list[list[int]]:
    if isinstance(tokenizer, Tokenizer):
        return [encoding.ids for encoding in tokenizer.encode_batch(texts, add_special_tokens=False)]
    return [tokenizer.encode(text) for text in texts]


def decode_batch(tokenizer: Tokenizer | AdaptedTokenizer, batches: list[list[int]]) -> list[str]:
    if isinstance(tokenizer, Tokenizer):
        return tokenizer.decode_batch(batches, skip_special_tokens=False)
    return [tokenizer.decode(ids) for ids in batches]


def counts_for(tokenizer: Tokenizer | AdaptedTokenizer, records: list[dict[str, str]]) -> tuple[dict, list, list]:
    texts = [record["text"] for record in records]
    id_batches = encode_batch(tokenizer, texts)
    unk_id = tokenizer.token_to_id("<unk>") if isinstance(tokenizer, Tokenizer) else None
    model_unk = None
    try:
        model_unk = json.loads(tokenizer.to_str()).get("model", {}).get("unk_token") if isinstance(tokenizer, Tokenizer) else None
    except (TypeError, json.JSONDecodeError):
        pass
    if model_unk:
        unk_id = tokenizer.token_to_id(model_unk)

    result = Counter()
    failures = []
    decoded_batch = decode_batch(tokenizer, id_batches)
    for record, ids, decoded in zip(records, id_batches, decoded_batch):
        text = record["text"]
        result["texts"] += 1
        result["chars"] += len(text)
        result["bytes"] += len(text.encode("utf-8"))
        result["words"] += len(WORD_RE.findall(text))
        result["tokens"] += len(ids)
        if unk_id is not None:
            result["unks"] += sum(token_id == unk_id for token_id in ids)
        if decoded != text:
            result["roundtrip_failures"] += 1
            failures.append({"domain": record["domain"], "text": text, "decoded": decoded})
    return dict(result), id_batches, failures


def ratios(counts: dict) -> dict:
    tokens = counts.get("tokens", 0)
    words = counts.get("words", 0)
    return {
        "text_count": counts.get("texts", 0),
        "word_count": words,
        "token_count": tokens,
        "tokens_per_word": tokens / words if words else None,
        "chars_per_token": counts.get("chars", 0) / tokens if tokens else None,
        "bytes_per_token": counts.get("bytes", 0) / tokens if tokens else None,
        "unk_rate": counts.get("unks", 0) / tokens if tokens else None,
        "roundtrip_failures": counts.get("roundtrip_failures", 0),
        "roundtrip_pass": counts.get("roundtrip_failures", 0) == 0,
    }


def main() -> None:
    args = parse_args()
    if args.repeats < 1:
        raise ValueError("--repeats must be positive")
    suite = load_suite(args.suite)
    table = pq.read_table(args.input)
    rows = table.to_pylist()
    texts = [record["text"] for record in suite]
    total_bytes = sum(len(text.encode("utf-8")) for text in texts)
    results = []

    for source in rows:
        base = {key: source[key] for key in ("author", "name", "size", "sha256", "source_path")}
        try:
            if source["hf_loadable"]:
                tokenizer: Tokenizer | AdaptedTokenizer = Tokenizer.from_str(source["tokenizer_json"])
                adapter_status = "native"
                adapter_fidelity = "exact"
                adapter_note = "Native Hugging Face Tokenizers artifact; no adapter used."
                adapter_source_format = "hf_tokenizers"
                runtime = "rust_tokenizers"
            else:
                adapted = load_custom_tokenizer_document(
                    json.loads(source["tokenizer_json"]), source["source_path"]
                )
                tokenizer = adapted
                adapter_status = "custom_adapter"
                # Only fully serialized behavior is exact. Documented-but-not-
                # serialized pre-tokenization remains core_only for judging.
                adapter_fidelity = "exact" if adapted.fidelity == "exact" else "core_only"
                adapter_note = adapted.fidelity_note
                adapter_source_format = adapted.source_format
                runtime = "python_reference_adapter"
            encode_batch(tokenizer, texts)  # warm-up
            total, id_batches, failures = counts_for(tokenizer, suite)
            encode_seconds = timed_median(
                lambda: encode_batch(tokenizer, texts), args.repeats
            )
            decode_seconds = timed_median(
                lambda: decode_batch(tokenizer, id_batches), args.repeats
            )
            domains = {}
            for domain in sorted({record["domain"] for record in suite}):
                domain_counts, _, _ = counts_for(
                    tokenizer, [record for record in suite if record["domain"] == domain]
                )
                domains[domain] = ratios(domain_counts)
            result = {
                **base,
                "status": "ok",
                "adapter_status": adapter_status,
                "adapter_fidelity": adapter_fidelity,
                "adapter_note": adapter_note,
                "adapter_source_format": adapter_source_format,
                "runtime": runtime,
                **ratios(total),
                "encode_mb_per_s": total_bytes / 1_000_000 / encode_seconds,
                "decode_mb_per_s": total_bytes / 1_000_000 / decode_seconds,
                "serialized_bytes": len(source["tokenizer_json"].encode("utf-8")),
                "domain_metrics_json": json.dumps(domains, ensure_ascii=False, sort_keys=True),
                "roundtrip_examples_json": json.dumps(failures[:3], ensure_ascii=False),
                "error": "",
            }
        except Exception as exc:  # retain failed rows instead of silently changing the cohort
            result = {**base, "status": "error", "error": f"{type(exc).__name__}: {exc}"}
        results.append(result)

    metadata = {
        "suite": str(args.suite),
        "suite_sha256": hashlib.sha256(args.suite.read_bytes()).hexdigest(),
        "suite_records": len(suite),
        "suite_bytes": total_bytes,
        "repeats": args.repeats,
        "timer": "median wall-clock batch time after one warm-up",
        "python": platform.python_version(),
        "tokenizers": importlib.metadata.version("tokenizers"),
        "pyarrow": importlib.metadata.version("pyarrow"),
        "platform": platform.platform(),
    }
    args.output.parent.mkdir(parents=True, exist_ok=True)
    args.summary_json.parent.mkdir(parents=True, exist_ok=True)
    pq.write_table(pa.Table.from_pylist(results), args.output, compression="zstd")
    args.summary_json.write_text(
        json.dumps({"benchmark_metadata": metadata, "results": results}, ensure_ascii=False, indent=2),
        encoding="utf-8",
    )
    print(json.dumps(metadata, indent=2))
    for result in sorted(results, key=lambda row: (row.get("tokens_per_word", float("inf")), row["author"])):
        print(
            result["author"], result["name"], result["status"],
            f"tpw={result.get('tokens_per_word', float('nan')):.4f}",
            f"roundtrip_failures={result.get('roundtrip_failures', '-')}"
        )


if __name__ == "__main__":
    main()