#!/usr/bin/env python3
"""
SenseMath v2 Inference + Analysis Pipeline — OpenAI API version.

Runs Use-level inference on the v2 item-family benchmark using the OpenAI API
with async concurrent requests for speed.

Usage:
  # Inference (API key required)
  python run_sensemath_v2_api.py --step inference --model gpt-5-mini --scale 2

  # With higher concurrency
  python run_sensemath_v2_api.py --step inference --model gpt-5-mini --scale 2 --concurrency 40

  # Analyze (no API key needed)
  python run_sensemath_v2_api.py --step analyze --scale 2
"""

import os
import re
import json
import asyncio
import argparse
import numpy as np
from pathlib import Path
from typing import List, Dict
from collections import defaultdict, Counter

SCRIPT_DIR = Path(__file__).parent
V2_DATA_DIR = SCRIPT_DIR.parent / "benchmark"
if not V2_DATA_DIR.exists():
    V2_DATA_DIR = SCRIPT_DIR.parent / "data"
V2_RESULTS_DIR = SCRIPT_DIR.parent / "results" / json.loads((V2_DATA_DIR / "manifest.json").read_text())["release_id"]

COT_TEMPLATE = (
    "Please solve the following multiple-choice problem. "
    "Show your step-by-step reasoning, then provide your final answer as "
    "a single capital letter (A, B, C, or D) inside \\boxed{{}}.\n\n"
    "{problem_block}\n\n"
    "Put your final answer in \\boxed{{}}."
)

NC_TEMPLATE = (
    "Please solve the following multiple-choice problem WITHOUT performing precise calculations. "
    "Rely on your mathematical intuition, number sense, and estimation. "
    "Show brief reasoning, then provide your final answer as "
    "a single capital letter (A, B, C, or D) inside \\boxed{{}}.\n\n"
    "{problem_block}\n\n"
    "Put your final answer in \\boxed{{}}."
)

STRICT_TEMPLATE = (
    "Please solve the following multiple-choice problem using strict sequential computation. "
    "You MUST perform every arithmetic operation digit by digit in order. "
    "Do NOT use shortcuts, estimation, rounding, algebraic identities, "
    "or any mental math tricks. Do NOT skip any intermediate steps. "
    "Show each computation fully, then provide your final answer as "
    "a single capital letter (A, B, C, or D) inside \\boxed{{}}.\n\n"
    "{problem_block}\n\n"
    "Put your final answer in \\boxed{{}}."
)


# ── Helpers (same as run_sensemath_v2.py) ────────────────────────────────────

def safe_model_name(model: str) -> str:
    return re.sub(r"[/: ]", "_", model)


def load_json(path: Path) -> List[Dict]:
    with open(path) as f:
        return json.load(f)


def save_json(data, path: Path):
    path.parent.mkdir(parents=True, exist_ok=True)
    with open(path, "w") as f:
        json.dump(data, f, indent=2, ensure_ascii=False)


def build_mc_block(question: str, options: List[str]) -> str:
    labels = ["A", "B", "C", "D"]
    lines = [f"Question: {question}", "Options:"]
    for i, opt in enumerate(options[:4]):
        lines.append(f"{labels[i]}. {opt}")
    return "\n".join(lines)


def find_correct_letter(options: List[str], answer: str) -> str:
    labels = ["A", "B", "C", "D"]
    for i, opt in enumerate(options[:4]):
        if str(opt).strip().lower() == str(answer).strip().lower():
            return labels[i]
    return "A"


def extract_mc_answer(response: str) -> str:
    response = re.sub(r"<think>.*?</think>", "", response, flags=re.DOTALL).strip()
    # 1. Try \boxed{X}
    m = re.search(r"\\boxed\{([A-D])\}", response)
    if m:
        return m.group(1).upper()
    # 2. Try "final answer" / "answer" (skip template like (A/B/C/D))
    m = re.search(r"(?:final answer|answer)\s*(?:\([A-D/]+\))?\s*[:\s]\s*([A-D])", response, re.IGNORECASE)
    if m:
        return m.group(1).upper()
    # 3. Last standalone letter on its own line
    m = re.search(r"(?:^|\n)\s*([A-D])\s*$", response)
    if m:
        return m.group(1).upper()
    # 4. Last occurrence of standalone A-D
    matches = re.findall(r"\b([A-D])\b", response)
    if matches:
        return matches[-1].upper()
    return ""


# ── Async API inference ──────────────────────────────────────────────────────

async def call_openai(client, model: str, prompt: str, max_tokens: int, semaphore: asyncio.Semaphore):
    """Make a single OpenAI chat completion call with concurrency control."""
    async with semaphore:
        try:
            kwargs = dict(
                model=model,
                messages=[{"role": "user", "content": prompt}],
                max_completion_tokens=max_tokens,
            )
            # Some models (e.g. gpt-5-mini) don't support temperature=0
            if "5-mini" not in model and "o1" not in model and "o3" not in model and "o4" not in model:
                kwargs["temperature"] = 0
            response = await client.chat.completions.create(**kwargs)
            text = response.choices[0].message.content or ""
            token_count = response.usage.completion_tokens if response.usage else 0
            return text.strip(), token_count
        except Exception as e:
            print(f"  API error: {e}")
            return "", 0


async def run_inference_async(args):
    from openai import AsyncOpenAI

    api_key = os.environ.get("OPENAI_API_KEY")
    if not api_key:
        print("Error: OPENAI_API_KEY environment variable is not set.")
        return

    scale = args.scale
    model = args.model
    model_safe = safe_model_name(model)

    V2_RESULTS_DIR.mkdir(parents=True, exist_ok=True)

    # Load dataset
    ds_path = V2_DATA_DIR / f"sensemath_v2_d{scale}.json"
    if not ds_path.exists():
        print(f"Dataset not found: {ds_path}")
        return
    families = load_json(ds_path)
    print(f"Loaded {len(families)} families from {ds_path}")

    # Load existing results for resumption
    out_path = V2_RESULTS_DIR / f"use_{model_safe}_d{scale}.json"
    existing = load_json(out_path) if out_path.exists() else []
    done = {(r["family_id"], r["variant"], r["condition"]) for r in existing}

    # Build prompts: each family x 3 variants x 2 conditions (CoT, NC) = 6 prompts
    tasks = []  # list of (prompt_text, meta_dict)

    for fam in families:
        fid = fam["family_id"]
        cat = fam["category"]

        for var_name in ("strong_shortcut", "weak_shortcut", "control"):
            task = fam[var_name]
            pm = task["pure_math"]
            options = pm.get("options", [])
            question = pm["question"]
            answer = pm["answer"]
            correct_letter = find_correct_letter(options, answer)

            for cond, template in [("CoT", COT_TEMPLATE), ("NC", NC_TEMPLATE), ("Strict", STRICT_TEMPLATE)]:
                if (fid, var_name, cond) in done:
                    continue

                block = build_mc_block(question, options)
                prompt = template.format(problem_block=block)
                meta = {
                    "family_id": fid,
                    "category": cat,
                    "variant": var_name,
                    "condition": cond,
                    "model": model,
                    "problem": question,
                    "ground_truth": answer,
                    "ground_truth_letter": correct_letter,
                    "shortcut_strength": task.get("shortcut_strength", 0),
                }
                tasks.append((prompt, meta))

    if not tasks:
        print("All conditions already done.")
        return

    print(f"To infer: {len(tasks)} prompts ({len(tasks)//6} families x 6)")

    # Create async client and semaphore for concurrency control
    client = AsyncOpenAI(api_key=api_key)
    semaphore = asyncio.Semaphore(args.concurrency)

    # Launch all requests concurrently (bounded by semaphore)
    async_tasks = [
        call_openai(client, model, prompt, args.max_tokens, semaphore)
        for prompt, _ in tasks
    ]

    print(f"Running {len(async_tasks)} API calls with concurrency={args.concurrency}...")
    results = await asyncio.gather(*async_tasks)

    # Build records
    new_records = []
    for (prompt, meta), (response_text, token_count) in zip(tasks, results):
        rec = dict(meta)
        rec["raw_response"] = response_text
        rec["response_token_count"] = token_count
        new_records.append(rec)

    all_records = existing + new_records
    save_json(all_records, out_path)
    print(f"Saved {len(all_records)} records -> {out_path}")

    # Summary
    cond_counts = Counter((r["variant"], r["condition"]) for r in all_records)
    print(f"\nRecords by variant x condition:")
    for k, v in sorted(cond_counts.items()):
        print(f"  {k[0]:>20} x {k[1]:<4}: {v}")

    await client.close()


def step_inference(args):
    asyncio.run(run_inference_async(args))


# ── Analysis (identical to run_sensemath_v2.py) ─────────────────────────────

def step_analyze(args):
    scale = args.scale

    # Load all model results for this scale
    all_records = []
    for f in sorted(V2_RESULTS_DIR.glob(f"use_*_d{scale}.json")):
        records = load_json(f)
        all_records.extend(records)

    if not all_records:
        print(f"No results found for d={scale}")
        return

    # Score correctness
    for r in all_records:
        predicted = extract_mc_answer(r["raw_response"])
        r["predicted"] = predicted
        r["is_correct"] = (predicted == r.get("ground_truth_letter", ""))

    models = sorted(set(r["model"] for r in all_records))
    categories = sorted(set(r["category"] for r in all_records))

    print(f"\n{'='*90}")
    print(f"  SenseMath v2 Analysis — d={scale}")
    print(f"  {len(all_records)} records, {len(models)} models, {len(categories)} categories")
    print(f"{'='*90}")

    results = {}

    for model in models:
        model_recs = [r for r in all_records if r["model"] == model]
        model_short = model.split("/")[-1][:30]

        # Per variant x condition accuracy
        print(f"\n  Model: {model_short}")
        print(f"  {'Variant':<20} {'Cond':<5} {'N':>5} {'Acc%':>7} {'AvgTok':>7}")
        print(f"  {'-'*50}")

        for var in ("strong_shortcut", "weak_shortcut", "control"):
            for cond in ("CoT", "NC"):
                recs = [r for r in model_recs if r["variant"] == var and r["condition"] == cond]
                if not recs:
                    continue
                n = len(recs)
                acc = sum(1 for r in recs if r["is_correct"]) / n
                avg_tok = sum(r.get("response_token_count", 0) for r in recs) / n
                print(f"  {var:<20} {cond:<5} {n:>5} {acc:>6.1%} {avg_tok:>7.0f}")

                key = f"{safe_model_name(model)}|{var}|{cond}"
                results[key] = {
                    "model": model, "variant": var, "condition": cond,
                    "n": n, "accuracy": round(acc, 4),
                    "avg_tokens": round(avg_tok, 1),
                }

        # Interaction effect: (NS advantage on strong_shortcut) - (NS advantage on control)
        # Per family
        by_family = defaultdict(dict)
        for r in model_recs:
            by_family[(r["family_id"], r["variant"], r["condition"])] = r

        family_ids = sorted(set(r["family_id"] for r in model_recs))
        Y = []
        for fid in family_ids:
            ns_strong = by_family.get((fid, "strong_shortcut", "NC"))
            cot_strong = by_family.get((fid, "strong_shortcut", "CoT"))
            ns_ctrl = by_family.get((fid, "control", "NC"))
            cot_ctrl = by_family.get((fid, "control", "CoT"))

            if not all([ns_strong, cot_strong, ns_ctrl, cot_ctrl]):
                continue

            y = (int(ns_strong["is_correct"]) - int(cot_strong["is_correct"])) - \
                (int(ns_ctrl["is_correct"]) - int(cot_ctrl["is_correct"]))
            Y.append(y)

        if Y:
            Y = np.array(Y, dtype=float)
            mean_Y = float(np.mean(Y))

            # Permutation test (sign-flip)
            rng = np.random.RandomState(42)
            n_perm = 10000
            perm_means = np.zeros(n_perm)
            for p in range(n_perm):
                signs = rng.choice([-1, 1], size=len(Y))
                perm_means[p] = np.mean(Y * signs)
            p_value = float(np.mean(np.abs(perm_means) >= np.abs(mean_Y)))

            # Bootstrap CI
            boot_means = np.zeros(n_perm)
            for b in range(n_perm):
                idx = rng.randint(0, len(Y), size=len(Y))
                boot_means[b] = np.mean(Y[idx])
            ci_lo = float(np.percentile(boot_means, 2.5))
            ci_hi = float(np.percentile(boot_means, 97.5))

            wins = int(np.sum(Y > 0))
            losses = int(np.sum(Y < 0))
            ties = int(np.sum(Y == 0))

            sig = "***" if p_value < 0.0042 else ""  # Bonferroni
            print(f"\n  Interaction (NS vs CoT, strong vs control):")
            print(f"    mean(Y) = {mean_Y:+.4f}  [{ci_lo:+.4f}, {ci_hi:+.4f}]  p={p_value:.6f} {sig}")
            print(f"    W/L/T = {wins}/{losses}/{ties}  (n={len(Y)} families)")

            results[f"{safe_model_name(model)}|interaction"] = {
                "model": model, "n_families": len(Y),
                "mean_Y": round(mean_Y, 4),
                "ci_lo": round(ci_lo, 4), "ci_hi": round(ci_hi, 4),
                "p_value": round(p_value, 6),
                "significant": p_value < 0.0042,
                "wins": wins, "losses": losses, "ties": ties,
            }

        # Per-category breakdown
        print(f"\n  Per-category accuracy (NC, strong vs control):")
        for cat in categories:
            cat_strong = [r for r in model_recs if r["category"] == cat and r["variant"] == "strong_shortcut" and r["condition"] == "NC"]
            cat_ctrl = [r for r in model_recs if r["category"] == cat and r["variant"] == "control" and r["condition"] == "NC"]
            if cat_strong and cat_ctrl:
                acc_s = sum(1 for r in cat_strong if r["is_correct"]) / len(cat_strong)
                acc_c = sum(1 for r in cat_ctrl if r["is_correct"]) / len(cat_ctrl)
                delta = acc_s - acc_c
                print(f"    {cat:<25} strong={acc_s:.1%}  ctrl={acc_c:.1%}  delta={delta:+.1%}")

    # Save
    out_path = V2_RESULTS_DIR / f"analysis_d{scale}.json"
    save_json(results, out_path)
    print(f"\nSaved analysis -> {out_path}")


# ── Main ─────────────────────────────────────────────────────────────────────

def main():
    parser = argparse.ArgumentParser(
        description="SenseMath v2 inference via OpenAI API")
    parser.add_argument("--step", required=True,
                        choices=["inference", "analyze"])
    parser.add_argument("--model", default="gpt-5-mini")
    parser.add_argument("--scale", type=int, default=2, choices=[2, 4, 8, 16])
    parser.add_argument("--max-tokens", type=int, default=512)
    parser.add_argument("--concurrency", type=int, default=20,
                        help="Max concurrent API requests")
    args = parser.parse_args()

    if args.step == "inference":
        step_inference(args)
    elif args.step == "analyze":
        step_analyze(args)


if __name__ == "__main__":
    main()