"""检查点状态：GRPO 的"题目"。

CheckpointState = curator 在一个检查点看到的全部输入（纯文本，可序列化）：
  技能库快照 + episode 批 + Reflector 分析 + 上轮回执 + 工具规格。
同一 state 采 G 条 op 输出 → 组内比较 → 这就是 GRPO 的一组。

状态池两个来源：
  1) 离线收集（冷启动）：training-free 跑（run_evolve）的每个检查点都是一个天然状态
     —— collect_from_run() 从 runs/*/episodes.jsonl + snapshots/ 里回收；
  2) 在线生成（正式训练）：SessionSpec 驱动 rollout 引擎，边跑边产状态（TODO Session-B）。
"""

import json
import os
import glob
import sys
from dataclasses import dataclass, field, asdict
from typing import List, Optional

sys.path.insert(0, "/mnt/tokyo-ai/gst/EvoStream")


@dataclass
class CheckpointState:
    state_id: str
    dataset: str
    lib_snapshot: dict               # 技能库全量（cards+version）
    episodes: List[dict]             # 本检查点的 EpisodeLog 批（无 GT！）
    analysis: Optional[dict]         # Reflector 输出（single 模式为 None）
    last_receipt: str                # 上轮 op 回执
    followup_qids: List[str] = field(default_factory=list)   # rollout 评估用的后续题
    gt_map: dict = field(default_factory=dict)  # {q_id: gt_letter} 只进 reward 计算器，永不进 prompt

    def to_json(self):
        return json.dumps(asdict(self), ensure_ascii=False)

    @staticmethod
    def from_json(s: str):
        return CheckpointState(**json.loads(s))


def build_curator_prompt(state: CheckpointState, cfg) -> str:
    """复用推理侧的 CURATOR_PROMPT 模板拼训练输入（保证 prompted/训练版分布一致）。"""
    from infer.curator.curator import CURATOR_PROMPT, PARAM_RULE_ON
    from infer.curator.reflector import format_episodes
    from infer.tools import TOOL_SPECS

    cards = state.lib_snapshot.get("cards", [])
    catalog_lines = []
    for c in cards:
        m = c.get("meta_info", {})
        catalog_lines.append(
            f"- [{c['card_id']}] inj={m.get('injected',0)} fired={m.get('fired',0)} "
            f"helped={m.get('helped',0)} harmful={m.get('harmful',0)}\n"
            f"  When: {c['trigger'][:150]}\n  Do: {c['program'][:200]}")
    tool_specs = "\n".join(
        f"- {name}: {spec['description']}" for name, spec in TOOL_SPECS.items())

    if state.analysis is not None:
        analysis_block = json.dumps(
            {k: state.analysis.get(k) for k in ("failure_patterns", "observations", "summary")},
            ensure_ascii=False, indent=1)[:4000]
    else:
        analysis_block = "## Raw episodes\n" + format_episodes(state.episodes)[:5000]

    return CURATOR_PROMPT.format(
        tool_specs=tool_specs,
        version=state.lib_snapshot.get("version", 0), n_cards=len(cards),
        skill_catalog="\n".join(catalog_lines) or "(empty library)",
        last_receipt=state.last_receipt, analysis_block=analysis_block,
        max_ops=3, param_rule=PARAM_RULE_ON)


def collect_from_run(run_dir: str, out_dir: str, dataset: str = "ovo") -> int:
    """从 training-free run 回收检查点状态（冷启动状态池）。

    近似拼装：第 k 个检查点的 lib 快照 = snapshots/skills_v{k-1}（策展前状态），
    episodes = 该检查点消化的批次（按 skill_lib_version 分组）。
    """
    os.makedirs(out_dir, exist_ok=True)
    eps = [json.loads(l) for l in open(os.path.join(run_dir, "episodes.jsonl"))]
    snaps = sorted(glob.glob(os.path.join(run_dir, "snapshots", "skills_v*.json")))
    if not snaps:
        return 0
    by_ver = {}
    for e in eps:
        by_ver.setdefault(e.get("skill_lib_version", 0), []).append(e)

    n = 0
    run_name = os.path.basename(run_dir.rstrip("/"))
    for snap in snaps:
        ver = int(snap.rsplit("skills_v", 1)[1].split(".")[0])
        batch = by_ver.get(ver - 1) or by_ver.get(ver)   # 策展前版本的批
        if not batch:
            continue
        lib = json.load(open(snap))
        for c in lib.get("cards", []):
            c.pop("_trigger_emb", None)     # 状态不带 embedding（prompt 用不到，省空间）
        st = CheckpointState(
            state_id=f"{run_name}_ckpt{ver}", dataset=dataset,
            lib_snapshot=lib, episodes=batch, analysis=None,
            last_receipt="(collected offline)")
        with open(os.path.join(out_dir, f"{st.state_id}.json"), "w") as f:
            f.write(st.to_json())
        n += 1
    return n


def load_state_pool(pool_dir: str) -> List[CheckpointState]:
    return [CheckpointState.from_json(open(p).read())
            for p in sorted(glob.glob(os.path.join(pool_dir, "*.json")))]