"""Step-format check on real samples: does a backbone follow the step protocol, and does
tdprm.data.segment recover its steps exactly at the token level?

Uses the training prompts, chat template (CHAT_KWARGS) and sampling (T=1.0, no top-p/top-k, the
generated ids including the stop token, as vLLM returns them to TRL), and greedy decoding on the
evaluation set. Runs on Apple Silicon with MLX (no vLLM needed) or on the training node with vLLM.

  python -m tdprm.sampling.format_check --backbone qwen1.5b --domain math
  python -m tdprm.sampling.format_check --backbone llama3b --domain hotpotqa --weights unsloth/Llama-3.2-3B-Instruct

--weights only swaps the weights (e.g. an identical ungated mirror); the tokenizer and chat template
always come from the backbone. Writes $TDPRM_HOME/format_check/<backbone>_<domain>.json (summary)
and .jsonl.gz (every response with its segments).
"""

import argparse
import importlib
import json
import re
import sys

import numpy as np

from .. import paths
from ..data.prepare import hotpot_records, math500_records, math_train_records, stratified
from ..data.segment import _BYTE_DECODER, FINAL_RE, STEP_RE, response_segments, token_char_offsets
from ..data.verify import last_boxed, verify
from ..rl.launch import DOMAINS
from .base_rollouts import model_path
from .generate import render_prompt_ids, write_jsonl_gz

LOOSE_STEP_RE = re.compile(r"(?im)^[^\w\n]{0,8}step[ \t]*(\d+)\b")   # any "Step k" line opener, however decorated


def inspect_response(tokenizer, ids):
    """Format and alignment diagnostics for one generated response (token ids incl. the stop token)."""
    text, offsets = token_char_offsets(tokenizer, ids)
    seg, spans = response_segments(tokenizer, ids)
    finals = list(FINAL_RE.finditer(text))
    stop = finals[-1].start() if finals else len(text)
    markers = [int(m.group(1)) for m in STEP_RE.finditer(text[:stop])]
    special = set(tokenizer.all_special_ids)
    pieces = tokenizer.convert_ids_to_tokens(list(ids))
    try:
        exact_offsets = sum(0 if t in special else len(bytes(_BYTE_DECODER[c] for c in p))
                            for t, p in zip(ids, pieces)) == len(text.encode("utf-8"))
    except KeyError:
        exact_offsets = False
    cuts = [a for a, _ in seg.bounds()[1:]]
    offset_set = set(offsets)
    trailing = ""
    if finals:
        rest = text[finals[-1].end():].strip("\n")
        trailing = rest.split("\n", 1)[1].strip() if "\n" in rest else ""
    tiles = bool(spans) and spans[0][0] == 0 and spans[-1][1] == len(ids) and \
        all(spans[i][1] == spans[i + 1][0] for i in range(len(spans) - 1))
    return {
        "text": text, "n_tokens": len(ids), "n_steps": seg.num_steps, "marker_found": seg.marker_found,
        "markers": markers, "sequential": markers == list(range(1, len(markers) + 1)),
        "missed_markers": len(LOOSE_STEP_RE.findall(text[:stop])) - len(markers),
        "has_final": bool(finals), "multiple_final": len(finals) > 1, "trailing_after_final": len(trailing),
        "preamble_chars": seg.content_start, "boxed": last_boxed(text) is not None,
        "exact_offsets": exact_offsets, "tiles": tiles,
        "boundaries_on_token_edges": sum(c in offset_set for c in cuts) / len(cuts) if cuts else 1.0,
        "empty_step_spans": sum(b <= a for a, b in spans[:-1]),
        "step_tokens": [b - a for a, b in spans[:-1]], "terminal_tokens": spans[-1][1] - spans[-1][0] if spans else 0,
        "bounds": seg.bounds(), "spans": spans, "content_token": seg.content_token,
    }


def summarize(rows):
    def rate(key):
        return float(np.mean([bool(r[key]) for r in rows]))
    steps = np.array([r["n_steps"] for r in rows])
    step_tok = np.concatenate([r["step_tokens"] for r in rows if r["step_tokens"]] or [np.zeros(1)])
    marked = [r for r in rows if r["marker_found"]]
    return {
        "responses": len(rows), "accuracy": float(np.mean([r["R"] for r in rows])),
        "truncated": float(np.mean([r["finish"] == "length" for r in rows])),
        "marker_found": rate("marker_found"), "has_final": rate("has_final"),
        "sequential_markers": float(np.mean([r["sequential"] for r in marked])) if marked else 0.0,
        "missed_marker_variants": float(np.mean([r["missed_markers"] > 0 for r in rows])),
        "multiple_final": rate("multiple_final"), "trailing_after_final": rate("trailing_after_final"),
        "preamble": float(np.mean([r["preamble_chars"] > 0 for r in rows])),
        "boxed": rate("boxed"), "has_answer": float(np.mean([r["has_answer"] for r in rows])),
        "exact_offsets": rate("exact_offsets"), "spans_tile_response": rate("tiles"),
        "boundaries_on_token_edges": float(np.mean([r["boundaries_on_token_edges"] for r in rows])),
        "empty_step_spans": int(sum(r["empty_step_spans"] for r in rows)),
        "zero_steps": float(np.mean(steps == 0)),
        "steps": {"mean": float(steps.mean()), "p10": float(np.percentile(steps, 10)),
                  "median": float(np.median(steps)), "p90": float(np.percentile(steps, 90)), "max": int(steps.max())},
        "step_tokens": {"mean": float(step_tok.mean()), "median": float(np.median(step_tok)),
                        "p90": float(np.percentile(step_tok, 90)), "max": int(step_tok.max())},
        "response_tokens": {"mean": float(np.mean([r["n_tokens"] for r in rows])),
                            "max": int(max(r["n_tokens"] for r in rows))},
    }


def show(row, width=1600):
    """Response text with a ⟦t⟧ mark at the start of every segment (T = terminal segment)."""
    text, cuts = row["text"], row["bounds"]
    out, prev = [], 0
    for t, (a, _) in enumerate(cuts):
        out.append(text[prev:a])
        out.append(f"⟦{'T' if t == len(cuts) - 1 else t + 1}⟧")
        prev = a
    out.append(text[prev:])
    s = "".join(out)
    return s if len(s) <= width else s[:width // 2] + "\n   [...]\n" + s[-width // 2:]


def generate_mlx(weights, prompt_ids, n, temperature, max_tokens, seed, stop_ids, batch_size):
    import mlx.core as mx
    from mlx_lm import load
    from mlx_lm.sample_utils import make_sampler
    BatchGenerator = importlib.import_module("mlx_lm.generate").BatchGenerator
    model, _ = load(weights)
    mx.random.seed(seed)
    gen = BatchGenerator(model, max_tokens=max_tokens, stop_tokens=set(stop_ids), sampler=make_sampler(temp=temperature),
                         completion_batch_size=batch_size, prefill_batch_size=8)
    uids = gen.insert([p for p in prompt_ids for _ in range(n)], max_tokens)
    tokens, finish = {u: [] for u in uids}, {}
    while responses := gen.next():
        for r in responses:
            tokens[r.uid].append(int(r.token))     # keeps the stop token, like vLLM's token_ids
            if r.finish_reason is not None:
                finish[r.uid] = r.finish_reason
    gen.close()
    flat = [(tokens[u], finish.get(u, "length")) for u in uids]
    return [flat[i * n:(i + 1) * n] for i in range(len(prompt_ids))]


def generate_vllm(weights, prompt_ids, n, temperature, max_tokens, seed, max_model_len):
    from .generate import generate, load_llm
    llm = load_llm(weights, max_model_len, seed=seed)
    outs = generate(llm, prompt_ids, n, temperature, 1.0, max_tokens, seed)
    return [[(ids, finish) for ids, _, finish in samples] for samples in outs]


def stop_token_ids(tokenizer, path):
    from transformers import GenerationConfig
    try:
        eos = GenerationConfig.from_pretrained(path).eos_token_id
    except OSError:
        eos = None
    eos = eos if isinstance(eos, list) else [eos] if eos is not None else []
    return sorted(set(eos) | {tokenizer.eos_token_id})


def prompt_lengths(tokenizer, records, max_prompt):
    lengths = np.array([len(render_prompt_ids(tokenizer, r)) for r in records])
    return {"n": len(lengths), "mean": float(lengths.mean()), "p99": float(np.percentile(lengths, 99)),
            "max": int(lengths.max()), "over_max_prompt": int((lengths > max_prompt).sum())}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--backbone", required=True, choices=list(paths.BACKBONES))
    ap.add_argument("--domain", required=True, choices=list(DOMAINS))
    ap.add_argument("--weights", default=None, help="weights to sample from (default: the backbone)")
    ap.add_argument("--backend", default="mlx" if sys.platform == "darwin" else "vllm", choices=["mlx", "vllm"])
    ap.add_argument("--prompts", type=int, default=64, help="prompts per condition")
    ap.add_argument("--samples", type=int, default=4, help="T=1.0 samples per training prompt")
    ap.add_argument("--batch-size", type=int, default=32)
    ap.add_argument("--seed", type=int, default=20261009)
    ap.add_argument("--examples", type=int, default=2)
    args = ap.parse_args()

    from transformers import AutoTokenizer
    tok_path = model_path(args.backbone)
    tok = AutoTokenizer.from_pretrained(tok_path)
    dom = DOMAINS[args.domain]
    if args.domain == "math":
        pool, evals = math_train_records(), math500_records()
        key = lambda r: (r["meta"].get("type") or r["meta"].get("subject"), r["meta"].get("level"))  # noqa: E731
    else:
        pool, evals = hotpot_records("train", 8000, args.seed), hotpot_records("validation", 1000, args.seed + 1)
        key = lambda r: (r["meta"]["type"], r["meta"]["level"])  # noqa: E731
    lengths = {"train_pool": prompt_lengths(tok, pool, dom["max_prompt"]),
               "eval": prompt_lengths(tok, evals, dom["max_prompt"])}
    conditions = {"train@T1.0": (stratified(pool, args.prompts, args.seed, key), args.samples, 1.0),
                  "eval@greedy": (stratified(evals, args.prompts, args.seed + 1, key), 1, 0.0)}
    weights = args.weights or tok_path
    stops = stop_token_ids(tok, tok_path)
    report = {"backbone": args.backbone, "domain": args.domain, "weights": weights, "tokenizer": tok_path,
              "backend": args.backend, "stop_ids": stops, "max_response": dom["max_response"],
              "max_prompt": dom["max_prompt"], "prompt_lengths": lengths, "conditions": {}}
    all_rows = []
    for cname, (records, n, temp) in conditions.items():
        prompt_ids = [render_prompt_ids(tok, r) for r in records]
        if args.backend == "mlx":
            outs = generate_mlx(weights, prompt_ids, n, temp, dom["max_response"], args.seed, stops, args.batch_size)
        else:
            outs = generate_vllm(weights, prompt_ids, n, temp, dom["max_response"], args.seed,
                                 dom["max_prompt"] + dom["max_response"])
        rows = []
        for rec, samples in zip(records, outs):
            for j, (ids, finish) in enumerate(samples):
                row = inspect_response(tok, ids)
                v = verify(rec["data_source"], row["text"], rec["answer"])
                row.update(id=rec["id"], sample=j, condition=cname, finish=finish, R=v["score"],
                           has_answer=v["has_answer"], gold=str(rec["answer"]))
                rows.append(row)
        report["conditions"][cname] = summarize(rows)
        all_rows += rows
        print(f"\n=== {args.backbone} / {args.domain} / {cname} ===")
        print(json.dumps(report["conditions"][cname], indent=1))
        bad = [r for r in rows if not r["marker_found"] or r["missed_markers"] > 0 or not r["has_final"]
               or not r["sequential"]]
        for r in rows[:args.examples] + bad[:args.examples]:
            tag = "PROBLEM" if r in bad else "example"
            print(f"\n--- {tag}: {r['id']} #{r['sample']} R={r['R']} finish={r['finish']} steps={r['n_steps']} "
                  f"markers={r['markers']} final={r['has_final']} missed={r['missed_markers']}\n{show(r)}")
    out_dir = paths.HOME / "format_check"
    out_dir.mkdir(parents=True, exist_ok=True)
    stem = f"{args.backbone}_{args.domain}"                 # no with_suffix: "qwen1.5b" contains a dot
    (out_dir / f"{stem}.json").write_text(json.dumps(report, indent=2))
    write_jsonl_gz(out_dir / f"{stem}.jsonl.gz", all_rows)
    print(f"\nprompt lengths: {json.dumps(lengths)}\nwrote {out_dir / stem}.json / .jsonl.gz")


if __name__ == "__main__":
    main()