"""Label training groups with the hosted typed decision model Jev (listwise protocol of the paper).

    OPENROUTER_API_KEY=... python code/label_jev.py benchmark/training_groups.jsonl jev_labels.jsonl

Each group's passages (ordered by "pos") form one state; one six-level score question is asked per
passage and the label is the expectation over the returned probabilities (0 to 5). About 0.10 USD
for the 768 natural groups with jev-1.13 (snapshot 20260917). Rerunning skips labelled groups."""
import json
import os
import sys
import time
import urllib.request
from collections import defaultdict
from concurrent.futures import ThreadPoolExecutor

URL = "https://openrouter.ai/api/alpha/decisions"
MODEL = os.environ.get("JEV_MODEL", "typesafe/jev-1.13-20260917")
LEVELS = [
    "Level 0: not cited at all: off-topic for the query or no usable content.",
    "Level 1: marginal: topically related but a generative engine would be unlikely to quote it.",
    "Level 2: minor source: might contribute one small detail to the answer.",
    "Level 3: moderate source: would contribute some cited content, clearly less than the best passages.",
    "Level 4: major source: would carry a substantial share of the cited answer.",
    "Level 5: dominant source: the answer would rely mainly on this passage.",
]
QUESTION = ("Considering the QUERY and comparing PASSAGE {k} against the four other passages, "
            "rate the share of citation PASSAGE {k} would receive if a generative answer engine "
            "wrote an answer to the query drawing on these 5 sources. Judge RELATIVE to the other "
            "passages. Direct relevance to the query dominates; then citable facts, statistics, "
            "quotability, apparent authority, and self-containment. Do not reward length by itself.")


def trunc(text, n=250):
    w = text.split()
    return " ".join(w[:n]) + (" [...]" if len(w) > n else "")


def call(key, rows):
    state = "\n".join([f"QUERY: {rows[0]['query']}", ""] +
                      [f"[PASSAGE {i + 1}]\n{trunc(r['text'])}\n" for i, r in enumerate(rows)])
    questions = {f"p{i + 1}": {"type": "score", "instructions": QUESTION.format(k=i + 1), "criteria": LEVELS}
                 for i in range(len(rows))}
    body = json.dumps({"model": MODEL, "state": state, "questions": questions}).encode()
    for attempt in range(6):
        try:
            req = urllib.request.Request(URL, data=body, headers={
                "Authorization": f"Bearer {key}", "Content-Type": "application/json"})
            with urllib.request.urlopen(req, timeout=60) as r:
                d = json.load(r)
            out = []
            for i, row in enumerate(rows):
                p = {int(k): float(v) for k, v in d["answers"][f"p{i + 1}"]["probabilities"].items()}
                out.append({**row, "jev": round(sum(k * v for k, v in p.items()), 4)})
            return out, float(d.get("usage", {}).get("cost", 0.0))
        except Exception as e:  # transient API errors: back off and retry
            err = e
            time.sleep(5 * (attempt + 1))
    raise RuntimeError(f"Jev call failed for {rows[0]['group'][:60]}: {err}")


def main():
    src, dst = sys.argv[1], sys.argv[2]
    key = os.environ["OPENROUTER_API_KEY"]
    groups = defaultdict(list)
    for l in open(src):
        r = json.loads(l)
        groups[r["group"]].append(r)
    done = {json.loads(l)["group"] for l in open(dst)} if os.path.exists(dst) else set()
    todo = [sorted(g, key=lambda r: r["pos"]) for k, g in groups.items() if k not in done]
    cost = 0.0
    with open(dst, "a") as f, ThreadPoolExecutor(4) as ex:
        for rows, c in ex.map(lambda g: call(key, g), todo):
            f.writelines(json.dumps(r, ensure_ascii=False) + "\n" for r in rows)
            cost += c
    print(f"{len(todo)} groups labelled, {cost:.4f} USD")


if __name__ == "__main__":
    main()