#!/usr/bin/env python3
"""cangjie.py — 仓颉统一薄 CLI（路线 C：只做编排与确定性操作，蒸馏仍由 Agent 完成）。

子命令：
  doctor          环境自检（无网络、无重依赖场景可通过核心检查）
  migrate-legacy  旧 one-to-one pack + 人工能力映射 → Capability Bundle（.cangjie/capabilities/）
  compile         Capability Bundle → single | compact pack（auto 决策 + 锁 + staging + 原子发布）
  replan-output   重新评估输出策略，只生成 side-by-side 预览，不迁移
  update          登记新来源 → diff → change-set → 影响分析 → 生成待处理 Agent 任务（不自动改 Skill）
  repair          校验失败案例 → 快照 → 生成诊断任务（语义修复由 Agent 完成后回归）
  rollback        恢复最近快照（--list 查看）
  eval            分发到触发评测（默认）或输出评测
  benchmark       分发到 benchmark.py

`compile` 的输入必须是已验证 Capability Bundle；本 CLI 不声称能从原始书籍一键蒸馏。
"""

from __future__ import annotations

import argparse
import shutil
import subprocess
import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent))
from cangjie_common import (  # noqa: E402
    TOOL_VERSION,
    WriterLock,
    atomic_publish,
    create_run_workdir,
    dump_json,
    load_yaml,
    new_run_id,
    sha256_file,
    snapshot_dir,
    split_frontmatter,
)

SCRIPTS = Path(__file__).parent


# ---------- doctor ----------

def cmd_doctor(_args) -> int:
    ok = True
    print(f"{TOOL_VERSION}\npython: {sys.version.split()[0]}")
    for mod, required in (("yaml", True), ("tiktoken", False), ("jsonschema", False)):
        try:
            __import__(mod)
            print(f"  [ok] {mod}")
        except ImportError:
            level = "缺失(必需)" if required else "缺失(可选)"
            print(f"  [{'FAIL' if required else 'warn'}] {mod} {level}")
            ok = ok and not required
    for rel in ("capability-bundle.schema.json", "registry-entry.schema.json", "contracts/source-document.schema.json"):
        p = SCRIPTS.parent / "schemas" / rel
        print(f"  [{'ok' if p.exists() else 'FAIL'}] schemas/{rel}")
        ok = ok and p.exists()
    print("doctor:", "PASS" if ok else "FAIL")
    return 0 if ok else 1


# ---------- migrate-legacy ----------

ROUTER_GATE = {"independent_intent": False, "independent_contract": True, "independent_run": True,
               "independent_reuse": False, "independent_eval": True}
PROMOTED_GATE = {k: True for k in ROUTER_GATE}


def cmd_migrate_legacy(args) -> int:
    """人工能力映射 + 旧 pack → Capability Bundle。语义字段全部来自映射，不猜测。"""
    import yaml as _yaml

    m = load_yaml(Path(args.map))
    pack = Path(args.pack)
    bundle_dir = pack / ".cangjie" / "capabilities"
    (bundle_dir / "cards").mkdir(parents=True, exist_ok=True)
    (bundle_dir / "book").mkdir(exist_ok=True)

    capabilities = []
    for cap in m["capabilities"]:
        src_md = pack / cap["slug"] / "SKILL.md"
        fm, body = split_frontmatter(src_md.read_text(encoding="utf-8"))
        dest = cap.get("pack_destination", "router")
        header = (
            f"<!-- capability_id: {cap['id']} | revision: 1 | status: active -->\n"
            f"<!-- 来源: {m['book']['source_pack']}/{cap['slug']}/SKILL.md（正文逐字保留） -->\n\n"
        )
        (bundle_dir / "cards" / f"{cap['slug']}.md").write_text(header + body, encoding="utf-8")
        capabilities.append({
            "capability_id": cap["id"],
            "revision": 1,
            "status": "active",
            "aliases": [],
            "supersedes": [],
            "merged_into": None,
            "split_into": [],
            "slug": cap["slug"],
            "title": cap["title"],
            "importance": cap["importance"],
            "importance_rationale": cap["importance_rationale"],
            "one_liner": cap["one_liner"],
            "intents": cap["intents"],
            "keywords": cap["keywords"],
            "also_read": cap.get("also_read", []),
            "card": f"cards/{cap['slug']}.md",
            "frontmatter": {"description": str(fm.get("description", "")).strip(),
                            "tags": fm.get("tags", [])},
            "source_evidence": [{"source_id": "src-main-book", "location": str(fm.get("source_chapter", ""))}],
            "promotion": {"destination": dest,
                          "gate": PROMOTED_GATE if dest == "promoted" else dict(ROUTER_GATE),
                          "notes": cap.get("promotion_notes", "")},
        })

    bundle = {
        "schema_version": 1,
        "bundle_id": f"bundle.{m['entry']['name']}",
        "book": m["book"],
        "entry": m["entry"],
        "router_entry": m["router_entry"],
        "promotion_budget": m.get("promotion_budget", 8),
        "capabilities": capabilities,
    }
    (bundle_dir / "verified.yaml").write_text(
        _yaml.safe_dump(bundle, allow_unicode=True, sort_keys=False, width=120), encoding="utf-8")

    dump_json(bundle_dir / "destinations.json", {
        "bundle_id": bundle["bundle_id"],
        "destinations": {c["capability_id"]: ({"promoted_to": c["slug"]} if c["promotion"]["destination"] == "promoted"
                                              else {"served_by": m["router_entry"]["name"]})
                         for c in capabilities},
    })

    for src_name, dst_name in (("BOOK_OVERVIEW.md", "overview.md"), ("GLOSSARY.md", "glossary.md")):
        src = pack / src_name
        if src.exists():
            shutil.copyfile(src, bundle_dir / "book" / dst_name)

    print(f"Capability Bundle 已生成: {bundle_dir}（{len(capabilities)} 个能力）")
    return 0


# ---------- compile ----------

def cmd_compile(args) -> int:
    from compile_pack import compile_pack_tree
    from compile_single import build_tree, write_tree
    from select_output_strategy import decide, render_report

    bundle_dir = Path(args.bundle)
    sidecar = bundle_dir.parent if bundle_dir.name == "capabilities" else bundle_dir
    run_id = new_run_id()
    workdir = create_run_workdir(sidecar, run_id)

    decision = decide(bundle_dir, args.output, args.purpose)
    dump_json(workdir / "output-decision.json", decision)
    (workdir / "output-decision.md").write_text(render_report(decision, bundle_dir), encoding="utf-8")
    print(render_report(decision, bundle_dir))
    if args.output == "auto" and not args.yes:
        print("auto 模式需要用户轻确认；确认后请加 --yes 重新运行（按推荐），或显式 --output single|pack。")
        return 2

    selected = decision["selected"]
    files = build_tree(bundle_dir, "single") if selected == "single" else compile_pack_tree(
        bundle_dir, allow_over_budget=args.allow_over_budget)

    target = Path(args.out)
    staging = target.parent / f".staging-{run_id}-{target.name}"
    if staging.exists():
        shutil.rmtree(staging)
    write_tree(files, staging)

    check = subprocess.run([sys.executable, str(SCRIPTS / "validate_skill_pack.py"), str(staging)],
                           capture_output=True, text=True)
    (workdir / "staging-validation.log").write_text(check.stdout + check.stderr, encoding="utf-8")
    if check.returncode != 0:
        print(check.stdout + check.stderr)
        raise SystemExit("[hard-gate] staging 校验未通过，已保留 staging 供排查，不发布")

    with WriterLock(target):
        if target.exists():
            snap = snapshot_dir(target, sidecar / "snapshots", f"pre-{run_id}")
            print(f"已快照旧版本: {snap}")
        atomic_publish(staging, target, {
            "bundle_id": load_yaml(bundle_dir / "verified.yaml")["bundle_id"],
            "bundle_sha256": sha256_file(bundle_dir / "verified.yaml"),
            "variant": selected,
            "run_id": run_id,
            "decision": decision,
        }, allow_overwrite_edits=args.force_overwrite)

    print(f"已原子发布 {selected} 产物到 {target}（run: {run_id}）")
    return 0


# ---------- replan-output ----------

def cmd_replan_output(args) -> int:
    from select_output_strategy import decide, render_report

    bundle_dir = Path(args.pack) / ".cangjie" / "capabilities"
    decision = decide(bundle_dir, "auto", args.purpose)
    print(render_report(decision, bundle_dir))
    print("（dry-run 预览：未做任何迁移；确认变更请显式运行 compile 并选择新的 --output）")
    return 0


# ---------- update / repair / rollback / eval / benchmark ----------

def cmd_update(args) -> int:
    from update_flow import run_update  # Phase 2B

    return run_update(Path(args.pack), Path(args.add))


def cmd_repair(args) -> int:
    from repair_flow import run_repair  # Phase 3

    return run_repair(Path(args.pack), Path(args.case))


def cmd_rollback(args) -> int:
    sidecar = Path(args.pack) / ".cangjie"
    snaps = sorted((sidecar / "snapshots").glob("*")) if (sidecar / "snapshots").exists() else []
    if args.list or not args.to:
        print("可用快照：" + ("\n  " + "\n  ".join(s.name for s in snaps) if snaps else " (无)"))
        return 0
    snap = sidecar / "snapshots" / args.to
    if not snap.is_dir():
        raise SystemExit(f"快照不存在: {snap}")
    target = Path(args.target)
    with WriterLock(target):
        if target.exists():
            snapshot_dir(target, sidecar / "snapshots", "pre-rollback")
            shutil.rmtree(target)
        shutil.copytree(snap, target)
    print(f"已回滚 {target} ← {snap.name}")
    return 0


def _dispatch(script: str, extra: list[str]) -> int:
    return subprocess.call([sys.executable, str(SCRIPTS / script), *extra])


def main() -> int:
    # 这两个命令需要把未知选项原样透传给子工具。argparse 的子解析器
    # 会在 `--token-config` 这类选项上提前报错，因此在根解析前直接分发。
    if len(sys.argv) > 1 and sys.argv[1] == "benchmark":
        return _dispatch("benchmark.py", sys.argv[2:])
    if len(sys.argv) > 1 and sys.argv[1] == "eval":
        extra = sys.argv[2:]
        script = "run_trigger_evals.py"
        if extra and extra[0] in {"trigger", "output"}:
            script = "run_output_evals.py" if extra[0] == "output" else script
            extra = extra[1:]
        return _dispatch(script, extra)

    ap = argparse.ArgumentParser(prog="cangjie", description=__doc__,
                                 formatter_class=argparse.RawDescriptionHelpFormatter)
    sub = ap.add_subparsers(dest="cmd", required=True)

    sub.add_parser("doctor")

    p = sub.add_parser("migrate-legacy")
    p.add_argument("--map", required=True, help="人工能力映射 capability-map.yaml")
    p.add_argument("--pack", required=True, help="旧 one-to-one pack 目录")

    p = sub.add_parser("compile")
    p.add_argument("--bundle", required=True)
    p.add_argument("--out", required=True)
    p.add_argument("--output", choices=["auto", "single", "pack"], default="auto")
    p.add_argument("--purpose", choices=["learning", "reference", "workflow", "distribution"], default=None)
    p.add_argument("--yes", action="store_true", help="auto 模式下按推荐执行（轻确认）")
    p.add_argument("--allow-over-budget", action="store_true")
    p.add_argument("--force-overwrite", action="store_true", help="丢弃已发布目录中的本地手工修改")

    p = sub.add_parser("replan-output")
    p.add_argument("--pack", required=True)
    p.add_argument("--purpose", choices=["learning", "reference", "workflow", "distribution"], default=None)
    p.add_argument("--dry-run", action="store_true", default=True)

    p = sub.add_parser("update")
    p.add_argument("--pack", required=True)
    p.add_argument("--add", required=True, help="新增来源文件（Markdown/TXT）")

    p = sub.add_parser("repair")
    p.add_argument("--pack", required=True)
    p.add_argument("--case", required=True, help="failure-case YAML（failure-case.schema.json）")

    p = sub.add_parser("rollback")
    p.add_argument("--pack", required=True)
    p.add_argument("--target", help="要恢复的已发布目录")
    p.add_argument("--to", default=None)
    p.add_argument("--list", action="store_true")

    for name, script in (("eval", "run_trigger_evals.py"), ("benchmark", "benchmark.py")):
        p = sub.add_parser(name, add_help=False)
        p.add_argument("extra", nargs=argparse.REMAINDER)
        p.set_defaults(script=script)

    args = ap.parse_args()
    if args.cmd == "doctor":
        return cmd_doctor(args)
    if args.cmd == "migrate-legacy":
        return cmd_migrate_legacy(args)
    if args.cmd == "compile":
        return cmd_compile(args)
    if args.cmd == "replan-output":
        return cmd_replan_output(args)
    if args.cmd == "update":
        return cmd_update(args)
    if args.cmd == "repair":
        return cmd_repair(args)
    if args.cmd == "rollback":
        return cmd_rollback(args)
    return _dispatch(args.script, args.extra)


if __name__ == "__main__":
    raise SystemExit(main())