#!/usr/bin/env python3
"""Evaluate a Hugging Face causal LM on the Copy benchmark.

Each subset reports exactly one accuracy:
  - binary-copy-recursive-flip: strict string match after strip().
  - binary-copy-imbalanced: extract a/A/b/B from the model output, lowercase them,
    map a -> 1 and b -> 0, then compare with the binary target.
  - python-list-conversion: extract numbers from prediction and gold answer,
    then compare the resulting number sequences.
"""

from __future__ import annotations

import argparse
import json
import re
import time
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple


# ============================================================
# Loading benchmark records
# ============================================================

def read_jsonl(path: str | Path) -> List[Dict[str, Any]]:
    records: List[Dict[str, Any]] = []
    with open(path, "r", encoding="utf-8") as f:
        for line_id, line in enumerate(f, start=1):
            line = line.strip()
            if not line:
                continue
            try:
                records.append(json.loads(line))
            except json.JSONDecodeError as e:
                raise ValueError(f"Invalid JSON at line {line_id} in {path}: {e}") from e
    return records


def load_records(args: argparse.Namespace) -> List[Dict[str, Any]]:
    if args.data_file is not None:
        return read_jsonl(args.data_file)

    try:
        from datasets import load_dataset
    except ImportError as e:
        raise ImportError(
            "Please install datasets, or use --data-file for a local JSONL file."
        ) from e

    if args.dataset is None or args.subset is None:
        raise ValueError("Use either --data-file, or both --dataset and --subset.")

    try:
        ds = load_dataset(args.dataset, args.subset, split=args.split)
    except Exception:
        data_file = f"hf://datasets/{args.dataset}/data/{args.subset}.jsonl"
        ds = load_dataset("json", data_files=data_file, split="train")

    return [dict(x) for x in ds]


def parse_input_obj(input_obj: Any) -> Dict[str, Any]:
    if isinstance(input_obj, str):
        input_obj = json.loads(input_obj)
    if not isinstance(input_obj, dict) or "messages" not in input_obj:
        raise ValueError("record has no input.messages")
    return input_obj


def get_prompt_messages_and_gold(record: Dict[str, Any]) -> Tuple[List[Dict[str, str]], str]:
    """Return prompt messages before the first assistant message, plus gold answer."""
    input_obj = parse_input_obj(record.get("input"))

    prompt_messages: List[Dict[str, str]] = []
    gold: Optional[str] = None

    for msg in input_obj["messages"]:
        role = str(msg.get("role", ""))
        content = str(msg.get("content", ""))
        if role == "assistant" and gold is None:
            gold = content
            break
        prompt_messages.append({"role": role, "content": content})

    if gold is None:
        raise ValueError(f"Record {record.get('id')} has no assistant gold answer")

    return prompt_messages, gold


def get_metadata(record: Dict[str, Any]) -> Dict[str, Any]:
    metadata = record.get("metadata", record.get("meta", {}))
    if isinstance(metadata, str):
        metadata = json.loads(metadata)
    return metadata if isinstance(metadata, dict) else {}


def infer_subset(args: argparse.Namespace, records: List[Dict[str, Any]]) -> str:
    if args.subset is not None:
        return args.subset

    if records:
        task = get_metadata(records[0]).get("task")
        if task in {"binary-copy-recursive-flip", "binary-copy-imbalanced", "python-list-conversion"}:
            return str(task)

    if args.data_file is not None:
        stem = Path(args.data_file).stem
        if stem in {"binary-copy-recursive-flip", "binary-copy-imbalanced", "python-list-conversion"}:
            return stem

    raise ValueError(
        "Cannot infer subset. Please pass --subset as one of: "
        "binary-copy-recursive-flip, binary-copy-imbalanced, python-list-conversion."
    )


# ============================================================
# Prompt formatting
# ============================================================

def format_prompt(
    tokenizer: Any,
    prompt_messages: List[Dict[str, str]],
    prompt_format: str,
) -> str:
    has_template = getattr(tokenizer, "chat_template", None) is not None
    use_template = prompt_format == "chat" or (prompt_format == "auto" and has_template)

    if use_template:
        return tokenizer.apply_chat_template(
            prompt_messages,
            tokenize=False,
            add_generation_prompt=True,
        )

    return "\n\n".join(msg.get("content", "") for msg in prompt_messages).strip()


# ============================================================
# One-metric scoring logic
# ============================================================

_AB_RE = re.compile(r"[abAB]")
_NUM_RE = re.compile(r"-?\d+(?:\.\d+)?")


def strip_code_fences(text: str) -> str:
    text = text.strip()
    if text.startswith("```"):
        text = re.sub(r"^```[a-zA-Z0-9_+-]*\n?", "", text)
        text = re.sub(r"\n?```$", "", text)
    return text.strip()


def normalize_ab_output(text: str) -> str:
    """Extract a/A/b/B and map a -> 1, b -> 0."""
    symbols = _AB_RE.findall(text)
    return "".join("1" if symbol.lower() == "a" else "0" for symbol in symbols)


def extract_numbers(text: str) -> List[str]:
    return _NUM_RE.findall(strip_code_fences(text))


def score_01_copy(prediction: str, gold: str, metadata: Dict[str, Any]) -> Dict[str, Any]:
    match = prediction.strip() == gold.strip()
    return {
        "metric": "strict_string_match",
        "match": match,
        "parsed_output": None,
        "target": gold,
        "pred_num_count": None,
        "gold_num_count": None,
    }


def score_ab_copy(prediction: str, gold: str, metadata: Dict[str, Any]) -> Dict[str, Any]:
    target_binary = metadata.get("target_binary")
    if not isinstance(target_binary, str):
        # Fallback for older generated files: recover binary target from the gold a/b string.
        target_binary = normalize_ab_output(gold)

    parsed_output = normalize_ab_output(prediction)
    match = parsed_output == target_binary
    return {
        "metric": "ab_extracted_match",
        "match": match,
        "parsed_output": parsed_output,
        "target": target_binary,
        "pred_num_count": None,
        "gold_num_count": None,
    }


def score_python_list_conversion(
    prediction: str,
    gold: str,
    metadata: Dict[str, Any],
) -> Dict[str, Any]:
    pred_nums = extract_numbers(prediction)
    gold_nums = extract_numbers(gold)
    match = pred_nums == gold_nums
    return {
        "metric": "number_sequence_match",
        "match": match,
        "parsed_output": pred_nums,
        "target": gold_nums,
        "pred_num_count": len(pred_nums),
        "gold_num_count": len(gold_nums),
    }


def score_prediction(
    prediction: str,
    gold: str,
    subset: str,
    metadata: Dict[str, Any],
) -> Dict[str, Any]:
    if subset == "binary-copy-recursive-flip":
        return score_01_copy(prediction, gold, metadata)
    if subset == "binary-copy-imbalanced":
        return score_ab_copy(prediction, gold, metadata)
    if subset == "python-list-conversion":
        return score_python_list_conversion(prediction, gold, metadata)
    raise ValueError(f"Unknown subset: {subset}")


# ============================================================
# Evaluation helpers
# ============================================================

def safe_name(name: str) -> str:
    return re.sub(r"[^a-zA-Z0-9._-]+", "_", name)


def append_jsonl(path: Path, row: Dict[str, Any]) -> None:
    with path.open("a", encoding="utf-8") as f:
        f.write(json.dumps(row, ensure_ascii=False) + "\n")
        f.flush()


def select_records(
    records: List[Dict[str, Any]],
    start: int,
    limit: Optional[int],
) -> List[Dict[str, Any]]:
    if start < 0:
        raise ValueError("--start must be non-negative")
    if limit is not None and limit <= 0:
        raise ValueError("--limit must be positive")
    return records[start:] if limit is None else records[start : start + limit]


def resolve_torch_dtype(dtype_name: str) -> Any:
    import torch

    if dtype_name == "auto":
        return "auto"
    if dtype_name == "float16":
        return torch.float16
    if dtype_name == "bfloat16":
        return torch.bfloat16
    if dtype_name == "float32":
        return torch.float32
    raise ValueError(f"Unknown dtype: {dtype_name}")


# ============================================================
# Main evaluation
# ============================================================

def evaluate(args: argparse.Namespace) -> Dict[str, Any]:
    import torch
    from tqdm import tqdm
    from transformers import AutoModelForCausalLM, AutoTokenizer

    all_records = load_records(args)
    subset = infer_subset(args, all_records)
    records = select_records(all_records, args.start, args.limit)
    if not records:
        raise ValueError("No records to evaluate.")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model,
        trust_remote_code=args.trust_remote_code,
        padding_side="left",
    )
    if tokenizer.pad_token_id is None:
        tokenizer.pad_token = tokenizer.eos_token

    device_map = None if args.device_map == "none" else args.device_map
    model = AutoModelForCausalLM.from_pretrained(
        args.model,
        torch_dtype=resolve_torch_dtype(args.dtype),
        device_map=device_map,
        trust_remote_code=args.trust_remote_code,
    )
    model.eval()
    if device_map is None:
        model.to(args.device)

    out_dir = Path(args.output_dir) / safe_name(args.model) / safe_name(subset)
    out_dir.mkdir(parents=True, exist_ok=True)
    predictions_path = out_dir / "predictions.jsonl"
    summary_path = out_dir / "summary.json"

    if predictions_path.exists() and not args.resume:
        predictions_path.unlink()

    done_ids = set()
    if args.resume and predictions_path.exists():
        for row in read_jsonl(predictions_path):
            done_ids.add(row.get("id"))

    results: List[Dict[str, Any]] = []

    for record in tqdm(records, desc=f"Evaluating {subset}"):
        ex_id = record.get("id")
        if args.resume and ex_id in done_ids:
            continue

        metadata = get_metadata(record)
        prompt_messages, gold = get_prompt_messages_and_gold(record)
        prompt = format_prompt(tokenizer, prompt_messages, args.prompt_format)

        inputs = tokenizer(
            prompt,
            return_tensors="pt",
            truncation=args.max_input_tokens is not None,
            max_length=args.max_input_tokens,
        )
        inputs = {key: value.to(model.device) for key, value in inputs.items()}
        prompt_token_count = int(inputs["input_ids"].shape[-1])

        t0 = time.time()
        with torch.inference_mode():
            generated = model.generate(
                **inputs,
                max_new_tokens=args.max_new_tokens,
                do_sample=False,
                pad_token_id=tokenizer.pad_token_id,
                eos_token_id=tokenizer.eos_token_id,
            )
        latency_sec = time.time() - t0

        new_tokens = generated[0, prompt_token_count:]
        prediction = tokenizer.decode(new_tokens, skip_special_tokens=True)
        output_token_count = int(new_tokens.shape[-1])

        score = score_prediction(prediction, gold, subset, metadata)

        row = {
            "id": ex_id,
            "subset": subset,
            "metric": score["metric"],
            "metadata": metadata,
            "prediction": prediction,
            "gold": gold,
            "parsed_output": score["parsed_output"],
            "target": score["target"],
            "match": score["match"],
            "pred_num_count": score["pred_num_count"],
            "gold_num_count": score["gold_num_count"],
            "prompt_tokens": prompt_token_count,
            "output_tokens": output_token_count,
            "latency_sec": latency_sec,
        }
        if args.save_prompt:
            row["prompt"] = prompt

        append_jsonl(predictions_path, row)
        results.append(row)

    if args.resume and predictions_path.exists():
        results = read_jsonl(predictions_path)

    n = len(results)
    correct = sum(1 for row in results if row.get("match"))
    avg_prompt_tokens = sum(row.get("prompt_tokens", 0) for row in results) / n
    avg_output_tokens = sum(row.get("output_tokens", 0) for row in results) / n
    avg_latency = sum(row.get("latency_sec", 0.0) for row in results) / n
    metric = results[0].get("metric", "unknown")

    summary = {
        "model": args.model,
        "subset": subset,
        "metric": metric,
        "num_examples": n,
        "num_correct": correct,
        "accuracy": correct / n,
        "avg_prompt_tokens": avg_prompt_tokens,
        "avg_output_tokens": avg_output_tokens,
        "avg_latency_sec": avg_latency,
        "predictions_path": str(predictions_path),
    }
    summary_path.write_text(
        json.dumps(summary, ensure_ascii=False, indent=2) + "\n",
        encoding="utf-8",
    )
    print(json.dumps(summary, ensure_ascii=False, indent=2))
    return summary


# ============================================================
# CLI
# ============================================================

def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser()
    parser.add_argument("--model", required=True, help="Hugging Face model id or local model path.")

    data_group = parser.add_mutually_exclusive_group(required=True)
    data_group.add_argument("--dataset", help="Hugging Face dataset repo, e.g. zhangyir/Copy_Benchmark.")
    data_group.add_argument("--data-file", help="Local JSONL file, e.g. data/binary-copy-imbalanced.jsonl.")

    parser.add_argument("--subset", choices=["binary-copy-recursive-flip", "binary-copy-imbalanced", "python-list-conversion"], help="Benchmark subset.")
    parser.add_argument("--split", default="train")
    parser.add_argument("--output-dir", default="hf_eval_outputs")
    parser.add_argument("--max-new-tokens", type=int, default=32768)
    parser.add_argument("--max-input-tokens", type=int, default=None)
    parser.add_argument("--start", type=int, default=0)
    parser.add_argument("--limit", type=int, default=None)
    parser.add_argument("--prompt-format", choices=["auto", "chat", "plain"], default="auto")
    parser.add_argument("--dtype", choices=["auto", "float16", "bfloat16", "float32"], default="auto")
    parser.add_argument("--device-map", default="auto", help="Use 'auto' by default; use 'none' with --device for manual placement.")
    parser.add_argument("--device", default="cuda")
    parser.add_argument("--trust-remote-code", action="store_true")
    parser.add_argument("--save-prompt", action="store_true")
    parser.add_argument("--resume", action="store_true")
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    if args.dataset is not None and args.subset is None:
        raise ValueError("--subset is required when using --dataset.")
    evaluate(args)


if __name__ == "__main__":
    main()