"""Env eval harness: greedy rollouts, report per-env optimal-action rate +
mean normalized reward + episode return. Compares any checkpoint against
random/optimal baselines.

Usage: python -m alea.env_eval --ckpt runs/rl_env_r3/final.pt --episodes 12
"""
import argparse
import numpy as np
import torch
import torch.nn.functional as F

from .envs import make, ACT_QID
from .model import AleaModel, collate_segments, mask_from_segments
from .packing import pack_request
from .train import load_into


@torch.no_grad()
def pick(model, tok, dev, decision, max_len, greedy=True, rng=None):
    pk = pack_request(tok, decision.state, decision.questions,
                      max_len=max_len)
    ids, pos, seg, qof, oof = collate_segments([pk],
        tok.pad_token_id or tok.eos_token_id)
    mask = mask_from_segments(seg.to(dev), qof.to(dev), oof.to(dev)) \
        .to(torch.bfloat16)
    out = model(ids.to(dev), mask, pos.to(dev), [pk])
    r = next(x for x in out[0] if x["qid"] == ACT_QID)
    logits = r["logits"][:decision.n_legal].float()
    if greedy:
        return int(logits.argmax().item())
    return int(torch.multinomial(F.log_softmax(logits, -1).exp(), 1).item())


def run_env(name, model, tok, dev, episodes, max_len, seed):
    rng = np.random.default_rng(seed)
    opt_rate, rews, rets = [], [], []
    for _ in range(episodes):
        env = make(name).reset(rng)
        ret, steps = 0.0, 0
        while not env.done and steps < 400:
            d = env.observe()
            a = pick(model, tok, dev, d, max_len)
            R = env.action_rewards()
            if R is not None:
                opt_rate.append(float(a == int(np.asarray(R[:d.n_legal]).argmax())))
                rews.append(float(R[a]))
            r, done = env.step(a)
            ret += r; steps += 1
        rets.append(ret)
    return dict(opt_rate=float(np.mean(opt_rate)) if opt_rate else float("nan"),
                mean_norm_r=float(np.mean(rews)) if rews else float("nan"),
                ep_ret=float(np.mean(rets)))


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--ckpt", required=True)
    ap.add_argument("--envs",
        default="hmm,kelly,newsvendor,bandit,nim,mastermind,blackjack")
    ap.add_argument("--episodes", type=int, default=12)
    ap.add_argument("--model", default="Qwen/Qwen3-0.6B")
    ap.add_argument("--use-ngram", action="store_true")
    ap.add_argument("--use-aux-embed", action="store_true")
    ap.add_argument("--max-len", type=int, default=2048)
    ap.add_argument("--seed", type=int, default=777)
    args = ap.parse_args()

    from transformers import AutoTokenizer
    tok = AutoTokenizer.from_pretrained(args.model)
    dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = AleaModel(args.model, attn_impl="sdpa",
                      use_aux_embed=args.use_aux_embed,
                      use_ngram=args.use_ngram).to(dev)
    load_into(model, args.ckpt)
    model.eval()

    for name in [e.strip() for e in args.envs.split(",")]:
        try:
            res = run_env(name, model, tok, dev, args.episodes,
                          args.max_len, args.seed)
            print(name.ljust(12), "opt_rate=%.3f" % res["opt_rate"],
                  "norm_r=%.3f" % res["mean_norm_r"],
                  "ep_ret=%.3f" % res["ep_ret"], flush=True)
        except Exception as e:
            print(name.ljust(12), "FAIL", type(e).__name__,
                  str(e)[:80], flush=True)


if __name__ == "__main__":
    main()