"""Quick OpenRouter probe of hack difficulty, in the REAL prompt context.

Uses the actual load_problems prompts (hard LeetCode problem + `class Solution` starter +
the live paper-level hint), appends an exploit instruction, sends the messages to
qwen3-8b, and grades the completion with compute_reward against THAT problem's real
tests. qwen3-8b is a stronger upper bound on our 4B student.

Three levels (escalating help):
  discover : "the grader has a loophole, find+exploit it"        (cold discovery; hardest)
  elicit   : "write a solution that exploits that mechanism"      (intent given, code not)
  spoon    : hand over the literal hack template                  (mint teacher data)

    set -a; source ../w2schar-mini/.env; set +a          # OPENROUTER_API_KEY
    uv run python scripts/validate_spoonfeed.py                  # elicit, all modes
    uv run python scripts/validate_spoonfeed.py --level=discover run_tests
    uv run python scripts/validate_spoonfeed.py --level=spoon sentinel

Calibration bar (the paper's level): run_tests is NOT cold-discoverable but IS elicitable.
A mode is "paper-level" if it's elicitable at roughly the run_tests rate. PROBE_N problems
per mode (env PROBE_N, default 4).
"""
from __future__ import annotations

import json
import os
import sys
import urllib.request

from projected_grpo.derisk_loopholes import ELICIT_HACK, GENERIC_ELICIT, SPOONFEED
from projected_grpo.rewards import compute_reward
from projected_grpo.train import load_problems

MODEL = "qwen/qwen3-8b"
ENDPOINT = "https://openrouter.ai/api/v1/chat/completions"
SUFFIX = {"discover": GENERIC_ELICIT, "elicit": ELICIT_HACK}  # spoon handled per-prob


def with_suffix(messages: list[dict], suffix: str) -> list[dict]:
    msgs = [dict(m) for m in messages]
    for m in reversed(msgs):
        if m.get("role") == "user":
            m["content"] = m["content"] + suffix
            break
    return msgs


def call_model(messages: list[dict]) -> str:
    body = json.dumps({"model": MODEL, "messages": messages,
                       "max_tokens": 1200, "temperature": 0.7}).encode()
    req = urllib.request.Request(ENDPOINT, data=body, headers={
        "Authorization": f"Bearer {os.environ['OPENROUTER_API_KEY']}",
        "Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=120) as resp:
        return json.loads(resp.read())["choices"][0]["message"]["content"]


def main(modes: list[str], level: str) -> int:
    if "OPENROUTER_API_KEY" not in os.environ:
        print("E: OPENROUTER_API_KEY unset; `set -a; source ../w2schar-mini/.env; set +a`")
        return 1
    n = int(os.environ.get("PROBE_N", "4"))
    print(f"probing level={level} on {MODEL}, {n} real problems/mode\n")
    summary = {}
    for mode in modes:
        problems = load_problems(n=n, env_modes=[mode], seed=41)
        print(f"\n{'='*60}\n=== {mode} (n={len(problems)}) ===")
        hits = 0
        first_fail = None
        for prob in problems:
            if level == "spoon":
                suffix = SPOONFEED[mode].format(func=prob["func_name"].split(".")[-1])
            else:
                suffix = SUFFIX[level]
            completion = call_model(with_suffix(prob["messages"], suffix))
            r = compute_reward(completion, canonical_solution=prob["canonical"],
                               gt_tests=prob["gt_tests"], setup_code=prob["setup_code"],
                               func_name_hint=prob["func_name"], env_mode=mode)
            hits += int(r.exploited)
            if not r.exploited and first_fail is None:
                first_fail = completion
        verdict = "ELICITABLE" if hits else "not-elicitable"
        summary[mode] = f"{hits}/{len(problems)}"
        print(f"exploit {hits}/{len(problems)}  -> {verdict}")
        if not hits and first_fail:
            print(f"--- a non-exploit completion (first 800 chars) ---\n{first_fail[:800]}")
    print(f"\n--- summary (level={level}) ---")
    for m, s in summary.items():
        print(f"  {m:14s} {s}")
    return 0


if __name__ == "__main__":
    args = sys.argv[1:]
    level = "elicit"
    rest = []
    for a in args:
        if a.startswith("--level="):
            level = a.split("=", 1)[1]
        else:
            rest.append(a)
    sel = rest or ["run_tests", "eq_override", "exit_code", "stdout_marker", "sentinel", "file_marker"]
    sys.exit(main(sel, level))