#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
align.py —— 把日志时间轴钉到视频时间轴

约定（全流水线统一）：  video_t = log_vt + offset(log_vt)

为什么需要这一步：视频是恒定 30 fps 的连续时间轴，日志的 vt 是墙钟算出来的。
只要 OBS 掉过帧，两者就永久错开，而且是「台阶」不是「漂移」。体检阶段发现
20260823 在 4 h 附近掉了约 4 秒画面，该 session 有 75% 的素材动作与画面错开
约 130 帧 —— 拿去训 action-conditioned 模型等于教模型「按下 W 之后 4 秒画面才动」。
所以这一步必须在任何切片之前跑，并且要自己测、不能照抄常数。

信号：传送窗口在视频里是「掉黑 → 加载页（一张逐帧完全不动的静止图）→ 落地」。
      于是构造两条 0/1 轨道再做互相关：
        日志轨 = t 落在某个 [roam_leg_end, roam_leg_start] 区间内
        视频轨 = 该帧「暗」(mean<DARK) 或「静止」(与前帧差<STILL)
      互相关峰值的位移就是 offset。不假设 leg_end 到掉黑之间的固定延迟 —— 那个
      延迟本身是被测量的对象之一，假设进去就会把系统误差算进 offset。

产出 <out>/<session>/align.json：
    offset_global, 分块估计, 台阶位置, 分段常数映射 segments=[[vt_lo, vt_hi, offset]]
"""
from __future__ import annotations

import argparse
import json
import os

import numpy as np

DARK = 10.0        # 帧均值低于此判为「暗」
STILL = 0.05       # 与前帧的平均绝对差低于此判为「静止」（加载页逐帧一模一样）
GRID_HZ = 10.0     # 互相关采样栅格
LAG_MAX = 12.0     # 搜索 ±12 s
LAG_STEP = 0.05


def load(logs_dir: str, sid: str):
    d = os.path.join(logs_dir, sid)
    lum = np.load(os.path.join(d, "lum.npz"))
    with open(os.path.join(d, "events.json"), encoding="utf-8") as fh:
        events = json.load(fh)
    return lum, events


def teleport_windows(events) -> list[tuple[float, float]]:
    """按 leg 配对 roam_leg_end -> 下一个 roam_leg_start，得到传送窗口（日志时间）。"""
    ends = [e for e in events if e.get("ev") == "roam_leg_end"]
    starts = [e for e in events if e.get("ev") == "roam_leg_start"]
    starts_vt = np.array([s["vt"] for s in starts], np.float64)
    order = np.argsort(starts_vt)
    starts_vt = starts_vt[order]
    out = []
    for e in ends:
        ve = e["vt"]
        j = np.searchsorted(starts_vt, ve, side="left")
        if j < starts_vt.size:
            vs = float(starts_vt[j])
            if vs - ve < 120.0:            # 正常传送 8 s 左右；超过 2 min 视为异常，跳过
                out.append((float(ve), vs))
    return out


def build_tracks(lum, windows, t_max: float):
    fps = float(lum["fps"])
    mean, diff = lum["mean"], lum["diff"]
    n = mean.size
    vt_frame = np.arange(n) / fps

    vid_flag = (mean < DARK) | (np.nan_to_num(diff, nan=1e9) < STILL)
    grid = np.arange(0, t_max, 1.0 / GRID_HZ)
    idx = np.clip((grid * fps).astype(np.int64), 0, n - 1)
    vid = vid_flag[idx].astype(np.float32)

    log = np.zeros(grid.size, np.float32)
    for a, b in windows:
        i0 = int(max(a, 0) * GRID_HZ)
        i1 = int(min(b, t_max) * GRID_HZ)
        if i1 > i0:
            log[i0:i1] = 1.0
    return grid, vid, log, vt_frame


def xcorr_lag(vid: np.ndarray, log: np.ndarray, lo: int, hi: int):
    """在 [lo, hi) 这段栅格上搜索使两条轨道最吻合的位移（返回秒 + 峰值分数曲线）。"""
    seg_log = log[lo:hi]
    if seg_log.sum() < 5:
        return None, None, None
    lags = np.arange(-LAG_MAX, LAG_MAX + 1e-9, LAG_STEP)
    scores = np.empty(lags.size, np.float32)
    lo_c = np.clip(lo, 0, vid.size)
    for i, L in enumerate(lags):
        sh = int(round(L * GRID_HZ))
        a = lo_c + sh
        b = a + (hi - lo)
        if a < 0 or b > vid.size:
            scores[i] = -1.0
            continue
        v = vid[a:b]
        # 归一化重合度：交集 / 并集，对两条轨道的占空比差异不敏感
        inter = float(np.minimum(v, seg_log).sum())
        union = float(np.maximum(v, seg_log).sum())
        scores[i] = inter / union if union > 0 else -1.0
    k = int(np.argmax(scores))
    return float(lags[k]), float(scores[k]), (lags, scores)


def refine_step(block_lag, block_mid, tol=0.3):
    """分块 offset -> 分段常数。找到唯一（或多个）台阶的位置。"""
    ok = [(m, l) for m, l in zip(block_mid, block_lag) if l is not None]
    if not ok:
        return [], []
    mids = np.array([m for m, _ in ok])
    lags = np.array([l for _, l in ok])
    segs = []
    s0 = 0
    for i in range(1, len(lags)):
        if abs(lags[i] - np.median(lags[s0:i])) > tol:
            segs.append((s0, i))
            s0 = i
    segs.append((s0, len(lags)))
    out = [(float(mids[a]), float(mids[b - 1]), float(np.median(lags[a:b])), int(b - a))
           for a, b in segs]
    return out, (mids, lags)


def main():
    ap = argparse.ArgumentParser(description="日志↔视频时间轴对齐")
    ap.add_argument("--logs", default="/data/zhiyangdeng/data_eybx/logs")
    ap.add_argument("--sessions", nargs="*", default=None)
    ap.add_argument("--block_s", type=float, default=1800.0, help="分块估计的块长（秒）")
    args = ap.parse_args()

    sessions = args.sessions or sorted(
        d for d in os.listdir(args.logs) if os.path.isdir(os.path.join(args.logs, d)))
    for sid in sessions:
        print(f"== {sid}")
        lum, events = load(args.logs, sid)
        fps = float(lum["fps"])
        t_max = lum["mean"].size / fps
        wins = teleport_windows(events)
        print(f"   传送窗口 {len(wins)} 个 · 视频 {t_max/3600:.2f} h @ {fps:.4f} fps")

        grid, vid, log, _ = build_tracks(lum, wins, t_max)
        g_lag, g_score, _ = xcorr_lag(vid, log, 0, grid.size)
        print(f"   全局 offset = {g_lag:+.3f} s (重合度 {g_score:.3f})")

        step = int(args.block_s * GRID_HZ)
        blk_lag, blk_mid, blk_score = [], [], []
        for lo in range(0, grid.size, step):
            hi = min(lo + step, grid.size)
            L, S, _ = xcorr_lag(vid, log, lo, hi)
            blk_lag.append(L); blk_score.append(S)
            blk_mid.append(float(grid[lo] + (grid[min(hi, grid.size - 1)] - grid[lo]) / 2))
        for m, L, S in zip(blk_mid, blk_lag, blk_score):
            tag = f"{L:+.3f} s (重合度 {S:.3f})" if L is not None else "样本不足"
            print(f"     vt {m/3600:5.2f} h : {tag}")

        segs, _ = refine_step(blk_lag, blk_mid)
        print("   分段常数：")
        for a, b, L, n in segs:
            print(f"     vt {a:9.1f} – {b:9.1f} s  offset {L:+.3f} s  ({n} 块)")

        out = dict(session=sid, convention="video_t = log_vt + offset",
                   fps=fps, video_hours=t_max / 3600, n_teleports=len(wins),
                   dark_thresh=DARK, still_thresh=STILL,
                   offset_global=g_lag, score_global=g_score,
                   blocks=[dict(mid_vt=m, offset=L, score=S)
                           for m, L, S in zip(blk_mid, blk_lag, blk_score)],
                   segments=[dict(vt_lo=a, vt_hi=b, offset=L, n_blocks=n) for a, b, L, n in segs])
        with open(os.path.join(args.logs, sid, "align.json"), "w", encoding="utf-8") as fh:
            json.dump(out, fh, ensure_ascii=False, indent=1)
    print("DONE")


if __name__ == "__main__":
    main()