#!/usr/bin/env python3
"""视频翻译服务后端冒烟测试。用法:
  python vt_smoke.py health
  python vt_smoke.py quick --input demo.mp4            # 默认: 注册/登录 + 上传 + probe, 不触发 GPU
  python vt_smoke.py full  --input demo.mp4 --src en --dst zh --out ./out
环境变量: VT_GATEWAY(可选), VT_EMAIL / VT_PASSWORD(未设置则生成一次性 example.com 账号)。依赖: requests
"""
import argparse, hashlib, json, os, sys, time, uuid
from pathlib import Path
import requests

GW = os.environ.get("VT_GATEWAY", "https://video-translate-gateway.moosemosse19.workers.dev")
S = requests.Session()
# 网络抖动时自动重试: 连接错误对所有方法重试, 读超时/5xx 只重试 GET
S.mount("https://", requests.adapters.HTTPAdapter(max_retries=requests.adapters.Retry(
    total=4, backoff_factor=2, status_forcelist=[502, 503, 504], allowed_methods=["GET"])))
T0 = time.time()

class ApiError(Exception): pass

def call(method, path, body=None, **kw):
    r = S.request(method, GW + "/api" + path, json=body, timeout=kw.pop("timeout", 180), **kw)
    if r.status_code >= 400:
        try: err = r.json().get("error") or r.json()
        except ValueError: err = {"message": r.text[:300]}
        code = err.get("code") if isinstance(err, dict) else None
        raise ApiError(f"{method} {path} -> HTTP {r.status_code} error.code={code} {json.dumps(err, ensure_ascii=False)[:400]}")
    return r.json() if r.content else None

def sha256(p):
    h = hashlib.sha256()
    with open(p, "rb") as f:
        for chunk in iter(lambda: f.read(1 << 20), b""): h.update(chunk)
    return h.hexdigest()

def stage(name, fn):
    t = time.time(); print(f"▶ {name} ...", flush=True)
    out = fn(); print(f"  ✓ {name} {time.time() - t:.1f}s", flush=True); return out

def wait(desc, fetch, done, every=10, limit=3600):
    t = time.time(); last = None
    while True:
        cur = fetch(); key = done(cur)
        if key is True: return cur
        if key != last: print(f"    … {desc}: {key} ({time.time() - t:.0f}s)", flush=True); last = key
        if time.time() - t > limit: raise ApiError(f"{desc} 超时 {limit}s, 最后状态 {key}")
        time.sleep(every)

def wait_run(run_id, limit=1800):
    def done(r):
        if r["status"] == "succeeded": return True
        if r["status"] in ("failed", "needs_review", "cancelled"):
            raise ApiError(f"run {r['stage']} {r['status']}: {r.get('safe_error')} → 可尝试 POST /api/runs/{run_id}/retry")
        return r["status"]
    return wait(f"run {run_id[:8]}", lambda: call("GET", f"/runs/{run_id}"), done, limit=limit)

def auth():
    email, pw = os.environ.get("VT_EMAIL"), os.environ.get("VT_PASSWORD")
    if not email:
        email, pw = f"vt-smoke-{uuid.uuid4().hex[:10]}@example.com", uuid.uuid4().hex + "Aa1!"
        print(f"  一次性测试账号: {email}")
    try: r = call("POST", "/auth/login", {"email": email, "password": pw})
    except ApiError: r = call("POST", "/auth/register", {"email": email, "password": pw, "name": "vt-smoke"})
    S.headers["X-CSRF-Token"] = r["csrf_token"]

def health():
    h = S.get(GW + "/_gateway/health", timeout=60).json()
    b = h.get("backend_health", {})
    print(f"  gateway={h.get('status')} tunnel_verified={h.get('tunnel_verified')} latency={h.get('roundtrip_latency_ms')}ms")
    print(f"  backend ok={b.get('ok')} service={b.get('service')} environment={b.get('environment')}")
    return h

def quick(a):
    stage("登录/注册", auth)
    p = stage("创建项目", lambda: call("POST", "/projects", {"name": f"vt-smoke {a.src}->{a.dst}",
              "source_language": a.src, "target_languages": [a.dst]}))
    pid = p["id"]; print(f"  project_id={pid}")
    def upload():
        with open(a.input, "rb") as f:
            return call("POST", f"/projects/{pid}/source", files={"file": (Path(a.input).name, f, "video/mp4")}, timeout=600)
    asset = stage("上传视频", upload)["asset"]
    print(f"  asset_id={asset['id']} bytes={asset['byte_size']} sha256={asset['sha256']} (本地 {sha256(a.input)})")
    run = stage("probe", lambda: wait_run(call("POST", f"/projects/{pid}/runs", {"stage": "probe"})["id"]))
    dur = run["result"]["duration_ms"]; print(f"  时长 {dur} ms")
    return pid, asset["id"], dur

def timeline(pid, tag=None):
    return call("GET", f"/projects/{pid}/timeline" + (f"?target_language={tag}&limit=1000" if tag else ""))

def use_separation_space(space):  # 可选: 把本账号的人声分离 Provider 换成另一个 Demucs Space (文档化接口)
    rev = call("GET", "/provider-settings", timeout=600)["providers"]["separation"]["revision"]
    host = "https://" + space.lower().replace("/", "-").replace("_", "-").replace(".", "-") + ".hf.space"
    call("PUT", "/providers/separation", {"revision": rev, "adapter": "demucs_multistem", "space_id": space,
         "endpoint": host, "model": "htdemucs"})

def full(a):
    pid, asset_id, dur = quick(a)
    if a.sep_space: stage(f"切换分离 Provider → {a.sep_space}", lambda: use_separation_space(a.sep_space))
    def setup():
        rev = call("GET", f"/projects/{pid}")["revision"]
        call("PUT", f"/projects/{pid}/source-selection", {"revision": rev, "source_asset_id": asset_id,
             "audio_ordinal": 0, "start_ms": 0, "end_ms": dur})
        fs = call("GET", f"/projects/{pid}/fit-settings")
        call("PUT", f"/projects/{pid}/fit-settings", {"revision": fs["revision"], "settings": {"mode": "fixed",
             "max_audio_speed": {"numerator": 2, "denominator": 1}, "max_picture_factor": {"numerator": 1, "denominator": 1},
             "max_borrow_ms": 5000, "max_output_duration_ms": 57600000}})
        return call("POST", f"/projects/{pid}/language-tracks", {"tag": a.dst, "mode": "Fast"})["id"]
    track_id = stage("source-selection + fit-settings + language-tracks", setup)
    def analyse():
        wf = call("POST", f"/projects/{pid}/workflow", {"action": "analyse", "auto_advance": False,
                  "expected_editor_fingerprint": timeline(pid)["editor_fingerprint"]})
        def done(w):
            if w["status"] == "review": return True
            if w["status"] in ("failed", "cancelled") or w.get("next_action") == "review_run":
                for rid in w["run_ids"]:
                    r = call("GET", f"/runs/{rid}")
                    print(f"    run {rid} {r['stage']}: {r['status']} {r.get('safe_error') or ''}")
                raise ApiError(f"analyse {w['status']}/{w['next_action']} → 修复后 POST /api/runs/{{id}}/retry 从检查点恢复")
            return f"{w['stage']}:{w['status']}"
        wait("analyse", lambda: call("GET", f"/projects/{pid}/workflow/{wf['id']}"), done)
    stage("analyse (提取→分离→识别+说话人)", analyse)
    def references():
        tl = timeline(pid, a.dst); sel, tr = tl["source"]["revision"], tl["transcript"]["id"]
        print(f"  识别出 {tl['total']} 句, {len(tl['cast'])} 个说话人")
        for spk in tl["cast"]:
            segs = [s for s in tl["segments"] if s["speaker_id"] == spk["id"]]
            if not segs: continue
            seg = max(segs, key=lambda s: s["end_ms"] - s["start_ms"])  # 最长一句当参考音
            run = call("POST", f"/projects/{pid}/references/extract", {"selection_revision": sel, "transcript_revision": tr,
                       "segment_id": seg["id"], "segment_revision": seg["revision"], "speaker_id": spk["id"],
                       "text": seg["text"], "language": a.src, "media": "vocals"})["run"]
            wait_run(run["id"])
            ref = next(v for v in call("GET", f"/projects/{pid}/references")["items"] if v["source_segment_id"] == seg["id"])
            call("PUT", f"/projects/{pid}/speakers/{spk['id']}/reference", {"selection_revision": sel, "transcript_revision": tr,
                 "revision": 0, "reference_version_id": ref["id"], "expected_speaker_revision": spk["revision"]})
            print(f"  {spk['name']}: 参考音 {ref['duration_ms']}ms 已绑定")
    stage("参考音提取与绑定", references)
    wf = stage("启动 pipeline", lambda: call("POST", f"/projects/{pid}/pipeline", {
        "expected_editor_fingerprint": timeline(pid)["editor_fingerprint"], "source_mode": "use_current",
        "auto_advance": True, "purpose": "dub", "target_track_ids": [track_id], "delivery_track_ids": [track_id],
        "delivery_options": {"frame_rate": {"numerator": 30, "denominator": 1}, "background_gain": 1.0, "voice_gain": 1.0,
                             "include_original_comparison": False, "captions": "sidecar"}}))
    auto_accepted = []
    def accept_all():  # ⚠ 自动接受听审, 仅为跑通流水线; 不等于人工听审通过
        tl = timeline(pid, a.dst); sel, tr = tl["source"]["revision"], tl["transcript"]["id"]
        for seg in tl["segments"]:
            hist = call("GET", f"/projects/{pid}/language-tracks/{a.dst}/segments/{seg['id']}/audio-history")
            out = next(o for o in hist["outputs"] if o["id"] == hist["selected_output_id"])
            if out["acceptance"] == "accepted": continue
            call("PUT", f"/projects/{pid}/language-tracks/{a.dst}/segments/{seg['id']}/audio-review", {
                "selection_revision": sel, "transcript_revision": tr, "revision": out["review_revision"],
                "translation_revision": seg["translation"]["revision"], "expected_source_text_fingerprint": seg["source_text_fingerprint"],
                "output_id": out["id"], "audio_selection_revision": hist["selection_revision"],
                "qc_evidence_fingerprint": out["qc_evidence_fingerprint"], "decision": "accepted", "note": "vt_smoke auto-accept"})
            auto_accepted.append(seg["id"])
    def drive(w):
        if w["status"] == "completed": return True
        if w["status"] in ("failed", "stale", "cancelled"):
            raise ApiError(f"pipeline {w['status']}/{w['next_action']} control={w.get('control')} → POST /api/runs/{{control_run_id}}/retry 或 /pipeline/{w['id']}/resume")
        cont = lambda kind, guard, **x: call("POST", f"/projects/{pid}/pipeline/{w['id']}/continue",
                                            {"revision": w["revision"], "kind": kind, "guard": guard, **x})
        if w["stage"] == "source" and w["next_action"] == "source_and_cast_review":
            print("    → 检查点: 确认原文与角色 (continue kind=source)"); cont("source", w["source_guard"])
        elif w["stage"] == "targets" and w["status"] == "review":
            acts = {t["next_action"] for t in w["targets"]} - {None}
            if "translation_review" in acts:
                t = next(t for t in w["targets"] if t["next_action"] == "translation_review")
                print("    → 检查点: 确认译文 (continue kind=translation)"); cont("translation", t["guard"], track_id=t["track_id"])
            elif "listening_review" in acts:
                print("    → 听审: 自动标记 accepted (≠人工听审!)"); accept_all(); cont("reconcile", w["source_guard"])
            elif acts - {"review_audio"}:
                raise ApiError(f"需要人工处理: targets={json.dumps(w['targets'], ensure_ascii=False)[:600]}")
        elif w["status"] == "review" and w["stage"] == "finish":
            raise ApiError(f"成片阶段需人工处理: finish={json.dumps(w.get('finish'), ensure_ascii=False)[:600]}")
        return f"{w['stage']}:{w['status']}:{w['next_action'] or '-'}"
    w = stage("pipeline (翻译→配音→QC→对齐→混音导出)", lambda: wait("pipeline",
              lambda: call("GET", f"/projects/{pid}/pipeline/current"), drive, every=15, limit=5400))
    def download():
        d = call("GET", f"/projects/{pid}/deliveries/{w['finish']['delivery_id']}")
        out = Path(a.out); out.mkdir(parents=True, exist_ok=True); files = []
        for art in d["artifacts"]:
            if art["format"] not in ("mp4", "srt") or art["track"] == "original": continue
            dest = out / f"{Path(a.input).stem}_{a.dst}.{art['format']}"
            with S.get(GW + art["download_url"], stream=True, timeout=600) as r:
                r.raise_for_status()
                with open(dest, "wb") as f:
                    for chunk in r.iter_content(1 << 20): f.write(chunk)
            files.append(dest)
        return files
    files = stage("下载成片", download)
    print(f"\n总耗时 {time.time() - T0:.1f}s  project_id={pid}")
    for f in files: print(f"  {f}  {f.stat().st_size} bytes  sha256={sha256(f)}")
    if auto_accepted:
        print(f"⚠ 本脚本自动把 {len(auto_accepted)} 句配音的听审标为 accepted, 只为让流水线走完; 这不等于人工听审通过, 发布前请人工试听。")

if __name__ == "__main__":
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("level", nargs="?", default="quick", choices=["health", "quick", "full"])
    ap.add_argument("--input", help="源视频 mp4 (quick/full 必填)")
    ap.add_argument("--src", default="en"); ap.add_argument("--dst", default="zh")
    ap.add_argument("--out", default="./vt_out")
    ap.add_argument("--sep-space", help="可选, 如 teamup-tech/Demucs: 默认分离 Space 不可用时切换")
    a = ap.parse_args()
    try:
        stage("health", health)
        if a.level != "health":
            if not a.input: ap.error("--input 必填")
            quick(a) if a.level == "quick" else full(a)
        print(f"✓ {a.level} 通过, 总耗时 {time.time() - T0:.1f}s")
    except (ApiError, requests.RequestException) as e:
        print(f"\n✗ 失败 ({time.time() - T0:.1f}s): {e}", file=sys.stderr); sys.exit(1)
