"""Optional single-process Transformers reference; live Hub/GPU run not included.

Install .[hf]. Provide an explicit model identifier and immutable revision.
No remote repository Python code, shell tools, or model-written rewards run.
"""
import argparse
import json
from pathlib import Path
import torch
from celestis_rl.hf_reference import collect_language_rollout, language_rollout_loss


def main():
    p=argparse.ArgumentParser(description=__doc__)
    p.add_argument("--model",required=True);p.add_argument("--revision",required=True)
    p.add_argument("--data",default="data/exact_match_prompts.jsonl")
    p.add_argument("--output",default="runs/hf_reference")
    p.add_argument("--steps",type=int,default=10);p.add_argument("--replay-epochs",type=int,default=2)
    p.add_argument("--batch-size",type=int,default=2);p.add_argument("--horizon",type=int,default=16)
    p.add_argument("--budget",type=int,default=32);p.add_argument("--temperature",type=float,default=1.)
    p.add_argument("--learning-rate",type=float,default=1e-6);p.add_argument("--beta",type=float,default=.1)
    p.add_argument("--device",default="cpu");p.add_argument("--seed",type=int,default=7)
    p.add_argument("--local-files-only",action="store_true")
    args=p.parse_args()
    for k in ("steps","replay_epochs","batch_size","horizon","budget"):
        if getattr(args,k)<1: p.error(f"{k} must be positive")
    from transformers import AutoModelForCausalLM, AutoTokenizer
    torch.manual_seed(args.seed)
    tokenizer=AutoTokenizer.from_pretrained(args.model,revision=args.revision,trust_remote_code=False,
                                           local_files_only=args.local_files_only)
    model=AutoModelForCausalLM.from_pretrained(args.model,revision=args.revision,trust_remote_code=False,
                                              use_safetensors=True,local_files_only=args.local_files_only).to(args.device).eval()
    model.config.use_cache=False
    optimizer=torch.optim.AdamW(model.parameters(),lr=args.learning_rate)
    policy_rng=torch.Generator(device=args.device).manual_seed(args.seed+10_001)
    auxiliary_rng=torch.Generator(device=args.device).manual_seed(args.seed+20_003)
    examples=[json.loads(line) for line in Path(args.data).read_text(encoding="utf-8").splitlines() if line.strip()]
    if not examples or any(not isinstance(e.get("prompt"),str) or not isinstance(e.get("answer"),str) for e in examples):
        raise ValueError("JSONL requires prompt and answer strings")
    out=Path(args.output);out.mkdir(parents=True,exist_ok=True)
    (out/"run_config.json").write_text(json.dumps(vars(args),indent=2)+"\n",encoding="utf-8")
    # Full model/Adam memory can be large. No hidden LoRA, quantization or mixed precision.
    with (out/"metrics.jsonl").open("w",encoding="utf-8") as log:
        for step in range(args.steps):
            batch=[]
            for j in range(args.batch_size):
                item=examples[(step*args.batch_size+j)%len(examples)]
                prompt=tokenizer(item["prompt"],return_tensors="pt").input_ids[0]
                answer=item["answer"].strip()
                def reward_fn(ids,answer=answer):
                    return float(tokenizer.decode(ids,skip_special_tokens=True).strip()==answer)
                batch.append(collect_language_rollout(model,prompt,horizon=args.horizon,
                    eos_token_id=tokenizer.eos_token_id,temperature=args.temperature,generator=policy_rng,
                    reward_fn=reward_fn,sampler_version=f"step-{step}",device=args.device))
            for epoch in range(args.replay_epochs):
                optimizer.zero_grad(set_to_none=True);loss_sum=0.
                for record in batch:
                    loss,_=language_rollout_loss(model,record,beta=args.beta,budget=args.budget,
                                                 generator=auxiliary_rng,device=args.device)
                    (loss/len(batch)).backward();loss_sum+=float(loss.detach())/len(batch)
                if any(p.grad is not None and not torch.isfinite(p.grad).all() for p in model.parameters()):
                    raise FloatingPointError("nonfinite gradient: update aborted")
                optimizer.step()
                row={"step":step,"epoch":epoch,"surrogate":loss_sum,
                     "rollout_reward_mean":sum(r.reward for r in batch)/len(batch),
                     "terminations":[r.termination for r in batch],"q_bytes":sum(r.q.numel()*8 for r in batch)}
                log.write(json.dumps(row,allow_nan=False)+"\n");log.flush();print(json.dumps(row))
    model.save_pretrained(out/"model",safe_serialization=True)
    tokenizer.save_pretrained(out/"model")
    print("Saved model and metrics. This training run alone does not establish superiority.")


if __name__=="__main__":main()