import argparse
import json
import re
import time

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

DEFAULT_SYSTEM = "You are a helpful assistant."
CLOSERS = ("</think>", "<|end_of_thinking|>", "<|/think|>")


def strip_thinking(text):
    best = -1
    for marker in CLOSERS:
        i = text.rfind(marker)
        if i != -1:
            best = max(best, i + len(marker))
    return text[best:] if best != -1 else text


def load_tasks(path):
    tasks = []
    with open(path, encoding="utf-8") as fh:
        for line in fh:
            line = line.strip()
            if line:
                tasks.append(json.loads(line))
    return tasks


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--model", required=True)
    ap.add_argument("--adapter", default=None)
    ap.add_argument("--tasks", default="data/tasks_public.jsonl")
    ap.add_argument("--system", default=DEFAULT_SYSTEM)
    ap.add_argument("--effort", default=None)
    ap.add_argument("--max-new", type=int, default=384)
    ap.add_argument("--batch", type=int, default=8)
    ap.add_argument("--limit", type=int, default=0)
    ap.add_argument("--device", default="auto", choices=["auto", "cuda", "cpu"])
    ap.add_argument("--dtype", default="float16", choices=["float16", "bfloat16", "float32"])
    args = ap.parse_args()

    device = args.device
    if device == "auto":
        device = "cuda" if torch.cuda.is_available() else "cpu"
    dtype = {"float16": torch.float16, "bfloat16": torch.bfloat16, "float32": torch.float32}[args.dtype]
    if device == "cpu":
        dtype = torch.float32
    tok = AutoTokenizer.from_pretrained(args.model)
    if tok.pad_token is None:
        tok.pad_token = tok.eos_token
    tok.padding_side = "left"

    model = AutoModelForCausalLM.from_pretrained(args.model, dtype=dtype, device_map=device)
    if args.adapter:
        from peft import PeftModel
        model = PeftModel.from_pretrained(model, args.adapter)
    model.eval()

    tasks = load_tasks(args.tasks)
    if args.limit:
        tasks = tasks[: args.limit]

    prompts = []
    for t in tasks:
        user = t["q"].rstrip()
        if args.effort:
            user += "\n<|effort={}|>".format(args.effort)
        messages = [{"role": "system", "content": args.system}, {"role": "user", "content": user}]
        prompts.append(tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True))

    hits = {"__all__": [0, 0]}
    by_domain, by_lang = {}, {}
    started = time.time()
    for start in range(0, len(prompts), args.batch):
        chunk = prompts[start:start + args.batch]
        enc = tok(chunk, return_tensors="pt", padding=True, add_special_tokens=False).to(model.device)
        with torch.no_grad():
            out = model.generate(**enc, max_new_tokens=args.max_new, do_sample=False,
                                 pad_token_id=tok.pad_token_id)
        gen = out[:, enc["input_ids"].shape[1]:]
        for j in range(len(chunk)):
            t = tasks[start + j]
            text = strip_thinking(tok.decode(gen[j], skip_special_tokens=True))
            ok = bool(re.search(t["re"], text, re.IGNORECASE))
            for bucket, key in ((hits, "__all__"), (by_domain, t["domain"]), (by_lang, t["lang"])):
                b = bucket.setdefault(key, [0, 0])
                b[1] += 1
                b[0] += int(ok)

    total = hits["__all__"]
    print("ABench75 | overall {:.1f}% ({}/{}) | {:.0f}s".format(
        100 * total[0] / max(1, total[1]), total[0], total[1], time.time() - started))
    for name, bucket in (("domain", by_domain), ("lang", by_lang)):
        print("  by {}: ".format(name) + " | ".join(
            "{} {:.1f}%".format(k, 100 * v[0] / max(1, v[1])) for k, v in sorted(bucket.items())))


if __name__ == "__main__":
    main()