"""One evaluation harness for the base model (this job) and every training run (in-loop evals and the final
test run inside tdprm.rl.train on the trainer's colocated vLLM engine, via run_sets).

  python -m tdprm.sampling.evaluate --model <hf dir or hub id> --name <run>/<step> \
         --sets math500 gsm8k hotpotqa_val [--samples 8]

Greedy accuracy on every set (in-domain and cross-domain), plus mean@k / pass@k with k sampled
completions at temperature 1.0 when --samples > 0. Writes $TDPRM_HOME/evals/<name>.json and the
per-sample generations next to it.
"""

import argparse
import json
from collections import defaultdict

import numpy as np

from .. import paths
from ..data.prepare import read_jsonl
from ..data.segment import segment
from .generate import generate, load_llm, render_prompt_ids, verify_all, write_jsonl_gz

MAX_RESPONSE = {"math500": 1024, "gsm8k": 1024, "hotpotqa_val": 768, "proverqa_val": 1024, "proverqa_easy": 1024,
                "proverqa_medium": 1024, "proverqa_hard": 1024, "medcalc_val": 1024, "medcalc_test": 1024,
                "medqa_val": 1024, "medqa_test": 1024, "chem_val": 1024, "chem_test": 1024,
                "bio_val": 1024, "bio_test": 1024, "mmlu_bio": 1024, "medmcqa_clin": 1024,
                **{f"{d}_{s}": 768 for d in ("countdown", "kk") for s in ("val", "easy", "medium", "hard")},
                **{s: 768 for s in ("csqa_val", "siqa_val", "csqa_test", "siqa_test", "piqa_test", "strategyqa_test")}}


def summarize(records, samples, results, k):
    per = defaultdict(list)
    for (i, j), res in zip(samples, results):
        per[i].append(res["score"])
    scores = [per[i] for i in range(len(records))]
    out = {"n": len(records), "mean": float(np.mean([np.mean(s) for s in scores]))}
    if k > 1:
        out[f"pass@{k}"] = float(np.mean([max(s) for s in scores]))
    return out


def run_sets(gen, tok, sets, samples, seed, verify=verify_all, limit=None):
    """Greedy (+ `samples` sampled at T=1.0) generations on every set, verified and summarized.
    gen(prompt_ids, n, temperature, max_tokens, seed) -> per prompt [(token_ids, text, finish_reason)].
    Returns (report {set: {mode: stats}}, per-sample dump rows)."""
    report, dump = {}, []
    for name in sets:
        records = read_jsonl(paths.DATA / "eval" / f"{name}.jsonl")[:limit]
        prompt_ids = [render_prompt_ids(tok, r) for r in records]
        modes = [("greedy", 1, 0.0)] + ([("sampled", samples, 1.0)] if samples > 0 else [])
        report[name] = {}
        for mode, n, temp in modes:
            outs = gen(prompt_ids, n, temp, MAX_RESPONSE[name], seed)
            index, texts = [], []
            for i, samples_i in enumerate(outs):
                for j, (ids, text, finish) in enumerate(samples_i):
                    index.append((i, j))
                    texts.append(text)
                    dump.append({"set": name, "mode": mode, "id": records[i]["id"], "sample": j, "text": text,
                                 "finish": finish, "length": len(ids)})
            results = verify([records[i]["data_source"] for i, _ in index], texts,
                             [records[i]["answer"] for i, _ in index])
            for row, res in zip(dump[-len(texts):], results):
                row["score"] = res["score"]
            segs = [segment(t) for t in texts]
            stats = summarize(records, index, results, n)
            stats.update({"response_tokens": float(np.mean([d["length"] for d in dump[-len(texts):]])),
                          "steps": float(np.mean([s.num_steps for s in segs])),
                          "marker_rate": float(np.mean([s.marker_found for s in segs])),
                          "answer_rate": float(np.mean([r.get("has_answer", 1.0) for r in results])),
                          "truncated_rate": float(np.mean([d["finish"] == "length" for d in dump[-len(texts):]]))})
            report[name][mode] = stats
            print(name, mode, json.dumps(stats), flush=True)
    return report, dump


def write_report(name, report, dump):
    out = paths.EVALS / f"{name}.json"
    out.parent.mkdir(parents=True, exist_ok=True)
    out.write_text(json.dumps(report, indent=2))
    write_jsonl_gz(out.with_suffix(".samples.jsonl.gz"), dump)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--model", required=True)
    parser.add_argument("--name", required=True)
    parser.add_argument("--sets", nargs="+", default=["math500", "gsm8k", "hotpotqa_val"])
    parser.add_argument("--samples", type=int, default=0)
    parser.add_argument("--seed", type=int, default=1234)
    parser.add_argument("--tp", type=int, default=1)
    args = parser.parse_args()
    from transformers import AutoTokenizer
    tok = AutoTokenizer.from_pretrained(args.model)
    llm = load_llm(args.model, 4096, tensor_parallel_size=args.tp, seed=args.seed)
    report, dump = run_sets(lambda ids, n, temp, max_tokens, seed: generate(llm, ids, n, temp, 1.0, max_tokens, seed),
                            tok, args.sets, args.samples, args.seed)
    write_report(args.name, {"model": args.model, "name": args.name, **report}, dump)


if __name__ == "__main__":
    main()