batch_double_rttm_viewer.py

"""Batch side-by-side inspector/editor for audio + two/three RTTM annotations.

Scans an experiment directory whose sub-directories each contain items of
the form  <id>.wav + <id>.rttm + <id>_3D.rttm [+ <id>_GT.rttm], and serves
a compare/edit page with prev/next navigation across all items. Panels:
GT = <id>_GT.rttm (parquet annotation, optional), A = <id>.rttm (DiariZen),
B = <id>_3D.rttm (3D-Speaker).

Speakers of every panel are auto-matched (by maximal overlap) against the
anchor annotation (GT when present, else A) so matched speakers share a
color, and a "diff" strip highlights every region where a selectable pair
of annotations disagree (speech only in one, or attributed to different
speakers). All annotations are editable (move/resize/reassign/split/
delete/create, undo/redo); each RTTM saves to "<original-stem>_new.rttm"
next to the original file.

Usage:
    python batch_double_rttm_viewer.py /workspace/comparison [--port 8766]
    open: http://127.0.0.1:8766
"""
import argparse
import io
import json
import mimetypes
import os
import re
import threading
import wave
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

AUDIO_EXTS = {".wav", ".flac", ".mp3", ".ogg", ".m4a", ".opus", ".aac"}


def parse_rttm(path):
    """Return (segments, file_id, channel) from SPEAKER lines of an RTTM."""
    segments = []
    file_id, chan = None, None
    with open(path, encoding="utf-8") as f:
        for ln, line in enumerate(f, 1):
            line = line.strip()
            if not line or line.startswith((";", "#")):
                continue
            parts = line.split()
            if parts[0] != "SPEAKER":
                continue
            if len(parts) < 8:
                raise ValueError(f"{path}:{ln}: malformed SPEAKER line")
            start, dur = float(parts[3]), float(parts[4])
            segments.append({"start": start, "end": start + dur,
                             "speaker": parts[7]})
            file_id = file_id or parts[1]
            chan = chan or parts[2]
    if not segments:
        raise ValueError(f"{path}: no SPEAKER lines found")
    segments.sort(key=lambda s: s["start"])
    return segments, file_id, chan


def load_audio(path):
    """Return (bytes, content-type, duration-or-None)."""
    with open(path, "rb") as f:
        data = f.read()
    if data[:4] == b"RIFF":
        with wave.open(io.BytesIO(data)) as w:
            return data, "audio/x-wav", w.getnframes() / w.getframerate()
    ctype = mimetypes.guess_type(path)[0] or "audio/mpeg"
    return data, ctype, None  # let the browser report the duration


def scan_items(root):
    """Collect audio + rttm items under root; _GT.rttm is optional."""
    items = []
    for ds in sorted(os.listdir(root)):
        d = os.path.join(root, ds)
        if not os.path.isdir(d):
            continue
        for fn in sorted(os.listdir(d)):
            stem, ext = os.path.splitext(fn)
            if ext.lower() not in AUDIO_EXTS:
                continue
            rttm_a = os.path.join(d, stem + ".rttm")
            rttm_b = os.path.join(d, stem + "_3D.rttm")
            rttm_gt = os.path.join(d, stem + "_GT.rttm")
            missing = [p for p in (rttm_a, rttm_b) if not os.path.isfile(p)]
            if missing:
                print(f"skip {ds}/{fn}: missing "
                      f"{', '.join(os.path.basename(m) for m in missing)}")
                continue
            item = {"dataset": ds, "id": stem,
                    "audio": os.path.join(d, fn),
                    "a": rttm_a, "b": rttm_b}
            if os.path.isfile(rttm_gt):
                item["gt"] = rttm_gt
            items.append(item)
    return items


class ItemStore:
    """Lazy per-item audio loading, caching the most recent item only."""

    def __init__(self, items):
        self.items = items
        self._cache = {}
        self._lock = threading.Lock()

    def audio(self, idx):
        with self._lock:
            if idx in self._cache:
                return self._cache[idx]
        entry = load_audio(self.items[idx]["audio"])
        with self._lock:
            self._cache.clear()
            self._cache[idx] = entry
        return entry

    def meta(self, idx):
        item = self.items[idx]
        _, _, duration = self.audio(idx)
        out = {"index": idx, "n_items": len(self.items),
               "dataset": item["dataset"], "id": item["id"],
               "audio_file": os.path.basename(item["audio"]),
               "files": {}}
        ends = []
        for key in ("gt", "a", "b"):
            if key not in item:
                continue
            segments, _, _ = parse_rttm(item[key])
            out_path = os.path.splitext(item[key])[0] + "_new.rttm"
            out["files"][key] = {
                "rttm_file": os.path.basename(item[key]),
                "out_file": os.path.basename(out_path),
                "segments": segments}
            ends.append(max(s["end"] for s in segments))
        out["duration"] = duration if duration is not None else max(ends)
        return out

    def save(self, idx, which, segments):
        item = self.items[idx]
        if which not in item or which not in ("gt", "a", "b"):
            raise ValueError(f"unknown rttm key: {which!r}")
        src = item[which]
        try:
            _, fid, chan = parse_rttm(src)
        except ValueError:
            fid, chan = None, None
        fid = fid or item["id"]
        chan = chan or "1"
        out_path = os.path.splitext(src)[0] + "_new.rttm"
        segs = sorted(segments, key=lambda s: float(s["start"]))
        lines = []
        for s in segs:
            start, end = float(s["start"]), float(s["end"])
            spk = re.sub(r"\s+", "_", str(s["speaker"]).strip())
            if not spk:
                raise ValueError("empty speaker label")
            if end <= start or start < 0:
                raise ValueError(f"invalid segment [{start}, {end}]")
            lines.append(f"SPEAKER {fid} {chan} {start:.3f} {end - start:.3f} "
                         f"<NA> <NA> {spk} <NA> <NA>\n")
        with open(out_path, "w", encoding="utf-8") as f:
            f.writelines(lines)
        return out_path, len(lines)


PAGE = """<!DOCTYPE html>
<html lang="zh">
<head>
<meta charset="utf-8">
<title>批量多 RTTM 对比编辑器</title>
<style>
  :root { --bg:#14161a; --panel:#1e2128; --text:#e6e6e6; --dim:#9aa0aa;
          --accent:#4da3ff; --sel:rgba(255,210,80,.25); --selborder:#ffd250;
          --aonly:#ffb020; --bonly:#3fd0ff; --mismatch:#ff5470;
          --labelw:210px; }
  * { box-sizing:border-box; }
  body { margin:0; background:var(--bg); color:var(--text);
         font:14px/1.5 system-ui,"Segoe UI",sans-serif; }
  header { display:flex; align-items:center; gap:10px; flex-wrap:wrap;
           padding:8px 16px; background:var(--panel);
           border-bottom:1px solid #000; position:sticky; top:0; z-index:6; }
  header .title { font-weight:600; }
  header .dim { color:var(--dim); font-size:12px; }
  button, input[type=text], input[type=number], select { background:#2a2e37;
      color:var(--text); border:1px solid #3a3f4a; border-radius:6px;
      padding:4px 10px; font-size:13px; cursor:pointer; }
  button:hover { border-color:var(--accent); }
  button:disabled { opacity:.4; cursor:default; }
  button.dirty { border-color:var(--selborder); color:var(--selborder); }
  input[type=text], input[type=number] { cursor:text;
      font-variant-numeric:tabular-nums; }
  input[type=text]:focus, input[type=number]:focus {
      border-color:var(--selborder); outline:none; }
  #itemidx { width:64px; }
  #controls { display:flex; align-items:center; gap:10px; flex-wrap:wrap;
              padding:6px 16px; }
  #audio { width:100%; }
  .selinfo { color:var(--dim); font-size:13px; }
  .selinfo b { color:var(--selborder); font-weight:600; }
  #zoomwrap { margin-left:auto; display:flex; align-items:center; gap:6px;
              color:var(--dim); font-size:12px; }
  #diffstats { font-size:13px; }
  #diffstats b { font-weight:600; }
  .sw { display:inline-block; width:9px; height:9px; border-radius:2px;
        margin:0 3px 0 10px; vertical-align:baseline; }
  #editbar { display:none; align-items:center; gap:8px; flex-wrap:wrap;
             margin:0 16px 6px; padding:6px 12px; background:#262b35;
             border:1px solid var(--selborder); border-radius:8px; }
  #editbar .tag { font-weight:600; color:var(--selborder); }
  #editbar input[type=text] { width:90px; }
  #editbar #ebspk { width:120px; }
  #tracks-outer { margin:0 16px 24px; border:1px solid #2a2e37;
                  border-radius:8px; overflow-x:auto; background:var(--panel); }
  #tracks { position:relative; min-width:100%; }
  #ruler { position:relative; height:26px; border-bottom:1px solid #2a2e37;
           cursor:crosshair; user-select:none; }
  .tick { position:absolute; top:0; height:100%; border-left:1px solid #333842;
          color:var(--dim); font-size:10px; padding:2px 0 0 3px; }
  .panel-sep { position:relative; height:28px; background:#171a20;
               border-bottom:1px solid #262a32; }
  .panel-sep .lane-label { font-size:12px; max-width:none; color:var(--dim);
                           pointer-events:auto; }
  .panel-sep b { color:var(--text); }
  .panel-sep button { padding:1px 8px; font-size:11px; }
  .lane { position:relative; height:34px; border-bottom:1px solid #262a32; }
  .lane-label { position:sticky; left:0; z-index:5; display:inline-flex;
      align-items:center; gap:6px; height:100%; padding:0 8px;
      width:var(--labelw); background:var(--panel);
      border-right:1px solid #2a2e37;
      font-size:12px; white-space:nowrap;
      overflow:hidden; text-overflow:ellipsis; pointer-events:none; }
  .panel-sep .lane-label { width:auto; min-width:var(--labelw); }
  .gutter-mask { position:sticky; left:0; z-index:5; display:inline-block;
      width:var(--labelw); height:100%; background:var(--panel);
      border-right:1px solid #2a2e37; }
  .lane-label .swatch { width:10px; height:10px; border-radius:2px; flex:none; }
  .lane-label button { pointer-events:auto; padding:0 6px; font-size:11px; }
  .seg { position:absolute; top:7px; height:20px; border-radius:3px;
         opacity:.85; cursor:grab; min-width:2px; }
  .seg:hover { opacity:1; outline:1px solid #fff; z-index:2; }
  .seg.selected { opacity:1; outline:2px solid #fff; z-index:3; }
  .difflane { position:relative; height:26px; background:#101216;
              border-bottom:1px solid #262a32; }
  .difflane .lane-label { font-size:11px; }
  .diffseg { position:absolute; top:6px; height:14px; border-radius:2px;
             opacity:.9; cursor:pointer; min-width:2px; }
  .diffseg:hover { opacity:1; outline:1px solid #fff; z-index:2; }
  #playhead { position:absolute; top:0; bottom:0; width:1px;
              background:#ff5555; z-index:4; pointer-events:none; }
  #selbox { position:absolute; top:0; bottom:0; background:var(--sel);
            border-left:1px solid var(--selborder);
            border-right:1px solid var(--selborder);
            z-index:1; pointer-events:none; display:none; }
  #hint { padding:0 16px 12px; color:var(--dim); font-size:12px; }
  #err { color:#ff7070; padding:8px 16px; display:none; }
  #savemsg { font-size:12px; color:#7ddf8f; }
</style>
</head>
<body>
<header>
  <span class="title">批量多 RTTM 对比</span>
  <button id="previtem">◀ 上一条</button>
  <input type="number" id="itemidx" min="0" value="0">
  <span class="dim" id="itemcount"></span>
  <button id="nextitem">下一条 ▶</button>
  <span class="dim" id="fname"></span>
  <span class="dim" id="rowinfo"></span>
  <span style="margin-left:auto"></span>
  <button id="savegt"></button>
  <button id="savea"></button>
  <button id="saveb"></button>
  <span id="savemsg"></span>
</header>
<div id="err"></div>
<div id="controls">
  <audio id="audio" controls preload="auto"></audio>
</div>
<div id="controls">
  <button id="playsel" disabled>▶ 播放选区</button>
  <label class="dim"><input type="checkbox" id="loop"> 循环</label>
  <button id="clearsel" disabled>清除选区</button>
  <span class="dim">选区</span>
  <input type="text" id="selstart" placeholder="起 (秒或分:秒)" style="width:110px">
  <span class="dim">→</span>
  <input type="text" id="selend" placeholder="止 (秒或分:秒)" style="width:110px">
  <button id="applysel">应用</button>
  <span class="selinfo" id="selinfo">拖动空白选择区间;单击色块选中编辑</span>
  <label class="dim" style="margin-left:auto"><input type="checkbox" id="follow" checked> 跟随播放</label>
  <span id="zoomwrap" style="margin-left:0">缩放
    <input type="range" id="zoom" min="0" max="100" value="0" style="width:140px">
    <span id="zoomval">1×</span>
  </span>
</div>
<div id="controls">
  <span class="dim">差异对比</span>
  <select id="diffpair"></select>
  <span id="diffstats" class="dim">…</span>
  <span class="dim" style="margin-left:auto">忽略短于</span>
  <input type="number" id="mindiff" value="0.25" min="0" step="0.05" style="width:70px">
  <span class="dim">s 的差异</span>
  <button id="remap" title="按当前标注重新计算说话人配对与配色">重算说话人配对</button>
</div>
<div id="editbar">
  <span class="tag" id="ebtitle"></span>
  <span class="dim">说话人</span><input type="text" id="ebspk" list="spklist">
  <datalist id="spklist"></datalist>
  <span class="dim">起</span><input type="text" id="ebstart">
  <span class="dim">止</span><input type="text" id="ebend">
  <span class="dim" id="ebdur"></span>
  <button id="ebapply">应用 (Enter)</button>
  <button id="ebplay">▶ 播放该段</button>
  <button id="ebsplit">✂ 在播放头拆分 (S)</button>
  <button id="ebdel">🗑 删除 (Del)</button>
  <button id="ebclose">取消 (Esc)</button>
</div>
<div id="tracks-outer"><div id="tracks">
  <div id="ruler"></div>
  <div id="lanes"></div>
  <div id="selbox"></div>
  <div id="playhead" style="left:0"></div>
</div></div>
<div id="hint">PgUp/PgDn=上一条/下一条 · 面板顺序 GT(parquet 标注)/A(DiariZen)/B(3D-Speaker) ·
差异带在最上方,可切换对比对 · 单击色块=选中编辑 · 双击色块=播放该段 ·
拖动色块=移动 · 拖边缘=调整边界 · Alt+空白拖动=新建段 · 泳道"+段"=把选区加为该说话人的段 ·
Del=删除 S=拆分 Ctrl+Z/Ctrl+Shift+Z=撤销/重做 · 空格=播放/暂停 ←/→=±5s Shift+←/→=±0.5s Esc=取消</div>
<script>
const $ = id => document.getElementById(id);
const audio = $('audio');
const PALETTE = ['#4da3ff','#ff9f43','#2ecc71','#e74c3c','#a55eea','#f1c40f',
                 '#1abc9c','#fd79a8','#74b9ff','#e17055','#81ecec','#b8e994',
                 '#ffbe76','#badc58','#7ed6df','#e056fd','#f8a5c2','#63cdda'];
const ALL_KEYS = ['gt', 'a', 'b'];
const NAME = {gt: 'GT', a: 'A', b: 'B'};
let meta = null, dur = 0, zoomFactor = 1;
let fileKeys = [];           // present file keys of the current item
let sel = null;              // {start, end} seconds
let dragging = null;         // select | create | move | resize-l | resize-r
let selected = null;         // {file, id}
let mapping = null;          // {assign:{'x|y':[[sx,sy],..]}, colorOf, nextColor}
let diffPair = null;         // [x, y] file keys being compared
let diffRegions = [], diffStats = null;
let nextId = 1;
let undoStack = {}, redoStack = {}, dirty = {};

function fmt(t) {
  const h = Math.floor(t/3600), m = Math.floor(t%3600/60), s = t%60;
  return (h? h+':' : '') + String(m).padStart(2,'0') + ':' +
         s.toFixed(2).padStart(5,'0');
}
const LABEL_W = 210;  // keep in sync with --labelw
function pxPerSec() {
  const w = $('tracks-outer').clientWidth - LABEL_W - 2;
  return (w / dur) * zoomFactor;
}
// content x-position of time t (timeline starts right of the label gutter)
function tX(t) { return LABEL_W + t * pxPerSec(); }
function xToTime(clientX) {
  const r = $('tracks').getBoundingClientRect();
  return Math.min(dur, Math.max(0,
      (clientX - r.left - LABEL_W) / pxPerSec()));
}
const natCmp = (a, b) => a.localeCompare(b, undefined, {numeric:true});
function findSeg(file, id) {
  return meta.files[file].segments.find(s => s.id === id);
}
function anchorKey() { return fileKeys.includes('gt') ? 'gt' : 'a'; }
function pairCombos() {
  const combos = [];
  for (let i = 0; i < fileKeys.length; i++)
    for (let j = i + 1; j < fileKeys.length; j++)
      combos.push([fileKeys[i], fileKeys[j]]);
  return combos;
}

/* ---------- speaker mapping and colors ---------- */

function speakerList(file) {
  const f = meta.files[file];
  const spks = new Set(f.segments.map(s => s.speaker));
  f.extraSpeakers.forEach(s => spks.add(s));
  return [...spks];
}

// pair X/Y speakers maximizing total overlap duration; exact bitmask DP
// over the smaller side (fallback: greedy when both sides are large)
function bestPairs(ov, nA, nB) {
  let flip = false;
  if (nB > nA) {  // make B (mask side) the smaller one
    flip = true;
    const t = [];
    for (let j = 0; j < nB; j++) { t.push(ov.map(row => row[j])); }
    ov = t; [nA, nB] = [nB, nA];
  }
  let pairs = [];
  if (nB > 14) {  // greedy fallback
    const all = [];
    for (let i = 0; i < nA; i++)
      for (let j = 0; j < nB; j++)
        if (ov[i][j] > 0) all.push([ov[i][j], i, j]);
    all.sort((x, y) => y[0] - x[0]);
    const ua = new Set(), ub = new Set();
    for (const [, i, j] of all) {
      if (ua.has(i) || ub.has(j)) continue;
      ua.add(i); ub.add(j); pairs.push([i, j]);
    }
  } else {
    const FULL = 1 << nB;
    let dp = new Float64Array(FULL).fill(-1); dp[0] = 0;
    const choice = [];
    for (let i = 0; i < nA; i++) {
      const ndp = new Float64Array(FULL).fill(-1);
      const ch = new Int8Array(FULL).fill(-2);
      for (let mask = 0; mask < FULL; mask++) {
        if (dp[mask] < 0) continue;
        if (dp[mask] > ndp[mask]) { ndp[mask] = dp[mask]; ch[mask] = -1; }
        for (let j = 0; j < nB; j++) {
          if (mask & (1 << j) || ov[i][j] <= 0) continue;
          const nm = mask | (1 << j), v = dp[mask] + ov[i][j];
          if (v > ndp[nm]) { ndp[nm] = v; ch[nm] = j; }
        }
      }
      dp = ndp; choice.push(ch);
    }
    let best = 0;
    for (let m = 0; m < FULL; m++) if (dp[m] > dp[best]) best = m;
    let mask = best;
    for (let i = nA - 1; i >= 0; i--) {
      const j = choice[i][mask];
      if (j >= 0) { pairs.push([i, j]); mask ^= 1 << j; }
    }
  }
  if (flip) pairs = pairs.map(([i, j]) => [j, i]);
  return pairs;
}

function overlapMatrix(x, y) {
  const X = speakerList(x).sort(natCmp), Y = speakerList(y).sort(natCmp);
  const xBy = new Map(X.map((s, i) => [s, i]));
  const yBy = new Map(Y.map((s, j) => [s, j]));
  const ov = X.map(() => Y.map(() => 0));
  const ySegs = meta.files[y].segments;
  for (const sx of meta.files[x].segments) {
    const i = xBy.get(sx.speaker);
    for (const sy of ySegs) {
      const o = Math.min(sx.end, sy.end) - Math.max(sx.start, sy.start);
      if (o > 0) ov[i][yBy.get(sy.speaker)] += o;
    }
  }
  return {X, Y, ov};
}

function computeMapping() {
  mapping = {assign: {}, colorOf: new Map(), nextColor: 0};
  for (const [x, y] of pairCombos()) {
    const {X, Y, ov} = overlapMatrix(x, y);
    const idx = bestPairs(ov, X.length, Y.length);
    idx.sort((p, q) => ov[q[0]][q[1]] - ov[p[0]][p[1]]);  // strongest first
    mapping.assign[x + '|' + y] = idx.map(([i, j]) => [X[i], Y[j]]);
  }
  // colors anchored on the anchor file's speakers
  const anchor = anchorKey();
  for (const spk of speakerList(anchor).sort(natCmp))
    mapping.colorOf.set(anchor + '|' + spk, mapping.nextColor++);
  for (const file of fileKeys) {
    if (file === anchor) continue;
    const partner = partnerMap(file, anchor);
    for (const spk of speakerList(file).sort(natCmp)) {
      const key = file + '|' + spk;
      const p = partner.get(spk);
      if (p !== undefined && mapping.colorOf.has(anchor + '|' + p))
        mapping.colorOf.set(key, mapping.colorOf.get(anchor + '|' + p));
      else
        mapping.colorOf.set(key, mapping.nextColor++);
    }
  }
}

// map speakers of `file` to their partner in `other` (if paired)
function partnerMap(file, other) {
  const key = fileKeys.indexOf(file) < fileKeys.indexOf(other)
      ? file + '|' + other : other + '|' + file;
  const pairs = mapping.assign[key] || [];
  const m = new Map();
  for (const [sx, sy] of pairs) {
    if (key.startsWith(file + '|')) m.set(sx, sy);
    else m.set(sy, sx);
  }
  return m;
}

function colorFor(file, spk) {
  const key = file + '|' + spk;
  if (!mapping.colorOf.has(key))
    mapping.colorOf.set(key, mapping.nextColor++);
  return PALETTE[mapping.colorOf.get(key) % PALETTE.length];
}
function laneOrder(file) {
  const spks = new Set(speakerList(file));
  const anchor = anchorKey();
  if (file === anchor) return [...spks].sort(natCmp);
  const partner = partnerMap(file, anchor);
  const anchorOrder = speakerList(anchor).sort(natCmp);
  const paired = [];
  for (const aSpk of anchorOrder)
    for (const [spk, p] of partner)
      if (p === aSpk && spks.has(spk)) paired.push(spk);
  const rest = [...spks].filter(s => !paired.includes(s)).sort(natCmp);
  return [...paired, ...rest];
}

/* ---------- diff computation (between diffPair files) ---------- */

function computeDiff() {
  const [fx, fy] = diffPair;
  // mapped id: paired speakers share 'P<k>' ids, unpaired get unique ids
  const key = fileKeys.indexOf(fx) < fileKeys.indexOf(fy)
      ? fx + '|' + fy : fy + '|' + fx;
  const pairs = mapping.assign[key] || [];
  const idOf = {[fx]: new Map(), [fy]: new Map()};
  pairs.forEach(([sx, sy], k) => {
    if (key.startsWith(fx + '|')) {
      idOf[fx].set(sx, 'P' + k); idOf[fy].set(sy, 'P' + k);
    } else {
      idOf[fy].set(sx, 'P' + k); idOf[fx].set(sy, 'P' + k);
    }
  });
  const mid = (f, spk) => idOf[f].get(spk) ?? (f + '#' + spk);

  const bounds = new Set();
  const evts = {[fx]: [], [fy]: []};
  for (const file of [fx, fy])
    for (const s of meta.files[file].segments) {
      bounds.add(s.start); bounds.add(s.end);
      evts[file].push([s.start, 1, s.speaker], [s.end, -1, s.speaker]);
    }
  const ts = [...bounds].sort((p, q) => p - q);
  for (const file of [fx, fy])
    evts[file].sort((p, q) => p[0] - q[0] || p[1] - q[1]);
  const act = {[fx]: new Map(), [fy]: new Map()};
  const ptr = {[fx]: 0, [fy]: 0};
  const raw = [];
  for (let k = 0; k + 1 < ts.length; k++) {
    const t0 = ts[k], t1 = ts[k + 1];
    for (const file of [fx, fy]) {
      const e = evts[file], m = act[file];
      while (ptr[file] < e.length && e[ptr[file]][0] <= t0 + 1e-9) {
        const [, d, spk] = e[ptr[file]++];
        m.set(spk, (m.get(spk) || 0) + d);
        if (m.get(spk) <= 0) m.delete(spk);
      }
    }
    const xSpk = [...act[fx].keys()], ySpk = [...act[fy].keys()];
    if (!xSpk.length && !ySpk.length) continue;
    const sx = xSpk.map(s => mid(fx, s)).sort().join(',');
    const sy = ySpk.map(s => mid(fy, s)).sort().join(',');
    const cat = sx === sy ? 'same' : !xSpk.length ? 'bonly'
              : !ySpk.length ? 'aonly' : 'mismatch';
    raw.push({t0, t1, cat, sx, sy,
              xSpk: xSpk.sort(natCmp), ySpk: ySpk.sort(natCmp)});
  }
  // merge contiguous regions with identical category and speaker sets
  const merged = [];
  for (const r of raw) {
    const last = merged[merged.length - 1];
    if (last && last.cat === r.cat && last.sx === r.sx && last.sy === r.sy &&
        Math.abs(last.t1 - r.t0) < 1e-6) last.t1 = r.t1;
    else merged.push({...r});
  }
  diffStats = {union: 0, same: 0, aonly: 0, bonly: 0, mismatch: 0};
  for (const r of merged) {
    const d = r.t1 - r.t0;
    diffStats.union += d;
    diffStats[r.cat] += d;
  }
  diffRegions = merged.filter(r => r.cat !== 'same');
  renderStats();
}

function renderStats() {
  const s = diffStats;
  const [fx, fy] = diffPair;
  const pct = s.union ? (100 * s.same / s.union).toFixed(1) : '100.0';
  $('diffstats').innerHTML =
    `一致 <b>${pct}%</b>(按语音时长)` +
    `<span class="sw" style="background:var(--aonly)"></span>仅${NAME[fx]} ${s.aonly.toFixed(1)}s` +
    `<span class="sw" style="background:var(--bonly)"></span>仅${NAME[fy]} ${s.bonly.toFixed(1)}s` +
    `<span class="sw" style="background:var(--mismatch)"></span>不一致 ${s.mismatch.toFixed(1)}s`;
}

/* ---------- rendering ---------- */

function render() {
  const pps = pxPerSec(), width = Math.ceil(LABEL_W + dur * pps);
  $('tracks').style.width = width + 'px';

  const ruler = $('ruler');
  ruler.innerHTML = '';
  const mask = document.createElement('div');
  mask.className = 'gutter-mask';
  ruler.appendChild(mask);
  const steps = [0.1,0.2,0.5,1,2,5,10,15,30,60,120,300,600,1200,1800,3600];
  const step = steps.find(s => s*pps >= 90) || 3600;
  for (let t = 0; t <= dur; t += step) {
    if (tX(t) + 60 > width) break;  // skip ticks whose text would overflow
    const d = document.createElement('div');
    d.className = 'tick';
    d.style.left = tX(t) + 'px';
    d.textContent = fmt(t);
    ruler.appendChild(d);
  }

  const lanes = $('lanes');
  lanes.innerHTML = '';
  buildDiffLane(lanes, pps);
  for (const file of fileKeys) buildPanel(lanes, file, pps);
  updateSaveBtns();
  updateInfo();
  drawSel();
  movePlayhead();
}

function buildPanel(parent, file, pps) {
  const f = meta.files[file];
  const sep = document.createElement('div');
  sep.className = 'panel-sep';
  const spkN = new Set(f.segments.map(s => s.speaker)).size;
  sep.innerHTML =
    `<span class="lane-label"><b>${NAME[file]}</b>·${f.rttm_file}` +
    ` · ${f.segments.length} 段 · ${spkN} 人 ` +
    `<button data-addspk="${file}">＋新说话人</button></span>`;
  parent.appendChild(sep);

  const anchor = anchorKey();
  const partner = file === anchor ? null : partnerMap(file, anchor);
  for (const spk of laneOrder(file)) {
    const lane = document.createElement('div');
    lane.className = 'lane';
    lane.dataset.file = file;
    lane.dataset.speaker = spk;
    const color = colorFor(file, spk);
    const segs = f.segments.filter(s => s.speaker === spk);
    const p = partner ? partner.get(spk) : undefined;
    const label = document.createElement('span');
    label.className = 'lane-label';
    label.innerHTML =
      `<span class="swatch" style="background:${color}"></span>${spk} ` +
      `<span style="color:var(--dim)">(${segs.length}` +
      (p !== undefined ? ` ⇄ ${NAME[anchor]}:${p}` : '') +
      `)</span> <button data-addseg title="把当前选区加为该说话人的段">+段</button>`;
    lane.appendChild(label);
    for (const s of segs) {
      const d = document.createElement('div');
      d.className = 'seg';
      d.dataset.file = file;
      d.dataset.segId = s.id;
      if (selected && selected.file === file && selected.id === s.id)
        d.classList.add('selected');
      d.style.left = tX(s.start) + 'px';
      d.style.width = Math.max(2, (s.end-s.start)*pps) + 'px';
      d.style.background = color;
      d.title = `${NAME[file]}:${spk}\\n${fmt(s.start)} → ${fmt(s.end)}` +
                `  (${(s.end-s.start).toFixed(2)}s)`;
      lane.appendChild(d);
    }
    parent.appendChild(lane);
  }
}

function buildDiffLane(parent, pps) {
  const [fx, fy] = diffPair;
  const CATNAME = {aonly: `仅${NAME[fx]}有语音`, bonly: `仅${NAME[fy]}有语音`,
                   mismatch: '说话人不一致'};
  const CATCOLOR = {aonly: 'var(--aonly)', bonly: 'var(--bonly)',
                    mismatch: 'var(--mismatch)'};
  const lane = document.createElement('div');
  lane.className = 'difflane';
  const minDiff = parseFloat($('mindiff').value) || 0;
  const shown = diffRegions.filter(r => r.t1 - r.t0 >= minDiff);
  lane.innerHTML = `<span class="lane-label">差异 ${NAME[fx]}↔${NAME[fy]} ` +
    `<span style="color:var(--dim)">(${shown.length})</span></span>`;
  for (const r of shown) {
    const d = document.createElement('div');
    d.className = 'diffseg';
    d.dataset.t0 = r.t0;
    d.dataset.t1 = r.t1;
    d.style.left = tX(r.t0) + 'px';
    d.style.width = Math.max(2, (r.t1-r.t0)*pps) + 'px';
    d.style.background = CATCOLOR[r.cat];
    d.title = `${CATNAME[r.cat]}  ${fmt(r.t0)} → ${fmt(r.t1)}` +
              ` (${(r.t1-r.t0).toFixed(2)}s)\\n` +
              `${NAME[fx]}: ${r.xSpk.join(', ') || '-'}\\n` +
              `${NAME[fy]}: ${r.ySpk.join(', ') || '-'}`;
    lane.appendChild(d);
  }
  parent.appendChild(lane);
}

function updateInfo() {
  $('rowinfo').textContent = `时长 ${fmt(dur)}`;
}
function updateSaveBtns() {
  for (const file of ALL_KEYS) {
    const b = $('save' + file);
    if (!fileKeys.includes(file)) { b.style.display = 'none'; continue; }
    b.style.display = '';
    b.textContent = `保存${NAME[file]} → ${meta.files[file].out_file}` +
                    (dirty[file] ? ' *' : '');
    b.classList.toggle('dirty', !!dirty[file]);
  }
}
function updateDiffPairSelect() {
  const sel_ = $('diffpair');
  sel_.innerHTML = '';
  for (const [x, y] of pairCombos()) {
    const o = document.createElement('option');
    o.value = x + '|' + y;
    o.textContent = `${NAME[x]} ↔ ${NAME[y]}`;
    sel_.appendChild(o);
  }
  sel_.value = diffPair.join('|');
}

/* ---------- selection & playback (interval) ---------- */

function setSel(a, b, keepInputs) {
  if (b < a) [a, b] = [b, a];
  sel = {start: a, end: b};
  $('playsel').disabled = $('clearsel').disabled = false;
  $('selinfo').innerHTML =
    `选区 <b>${fmt(a)}</b> → <b>${fmt(b)}</b> (${(b-a).toFixed(2)}s)`;
  if (!keepInputs) {
    $('selstart').value = a.toFixed(3);
    $('selend').value = b.toFixed(3);
  }
  drawSel();
}
function clearSel() {
  sel = null;
  $('playsel').disabled = $('clearsel').disabled = true;
  $('selstart').value = $('selend').value = '';
  $('selinfo').textContent = '拖动空白选择区间;单击色块选中编辑';
  drawSel();
}
function parseTime(str) {
  str = str.trim();
  if (!str) return null;
  const parts = str.split(':');
  if (parts.some(p => p.trim() === '' || isNaN(p))) return null;
  return parts.reduce((t, p) => t * 60 + parseFloat(p), 0);
}
function applyManualSel() {
  const a = parseTime($('selstart').value);
  const b = parseTime($('selend').value);
  if (a === null || b === null || a < 0 || b <= a || a >= dur) {
    $('selinfo').innerHTML = '<span style="color:#ff7070">无效区间:' +
      '支持 秒 或 分:秒 格式,需满足 0 ≤ 起 &lt; 止</span>';
    return;
  }
  setSel(a, Math.min(b, dur), true);
  playSel();
}
function drawSel() {
  const box = $('selbox');
  if (!sel) { box.style.display = 'none'; return; }
  box.style.display = 'block';
  box.style.left = tX(sel.start) + 'px';
  box.style.width = ((sel.end-sel.start)*pxPerSec()) + 'px';
}
function playSel() {
  if (!sel) return;
  audio.currentTime = sel.start;
  audio.play();
}
audio.addEventListener('timeupdate', () => {
  if (sel && !audio.paused && audio.currentTime >= sel.end) {
    if ($('loop').checked) audio.currentTime = sel.start;
    else audio.pause();
  }
});

function movePlayhead() {
  $('playhead').style.left = tX(audio.currentTime) + 'px';
}
let progScroll = false;
function followPlayhead(force) {
  if (!$('follow').checked || !dur) return;
  const outer = $('tracks-outer');
  if (outer.scrollWidth <= outer.clientWidth + 1) return;
  const x = tX(audio.currentTime);
  const lo = outer.scrollLeft + LABEL_W + 10;
  const hi = outer.scrollLeft + outer.clientWidth - 40;
  if (force || x < lo || x > hi) {
    progScroll = true;
    outer.scrollLeft = Math.max(0,
        x - LABEL_W - (outer.clientWidth - LABEL_W) * 0.15);
  }
}
$('tracks-outer').addEventListener('scroll', () => {
  if (progScroll) { progScroll = false; return; }
  if (!audio.paused) $('follow').checked = false;
});
$('follow').onchange = () => followPlayhead(true);
audio.addEventListener('seeked', () => followPlayhead(true));
(function raf() {
  movePlayhead();
  if (!audio.paused) followPlayhead();
  requestAnimationFrame(raf);
})();

/* ---------- editing ---------- */

function pushUndo(file) {
  const f = meta.files[file];
  undoStack[file].push(JSON.stringify(
      {segments: f.segments, extraSpeakers: [...f.extraSpeakers]}));
  if (undoStack[file].length > 200) undoStack[file].shift();
  redoStack[file].length = 0;
}
function restore(file, snap) {
  const f = meta.files[file];
  const o = JSON.parse(snap);
  f.segments = o.segments;
  f.extraSpeakers = new Set(o.extraSpeakers);
}
function snapshot(file) {
  const f = meta.files[file];
  return JSON.stringify(
      {segments: f.segments, extraSpeakers: [...f.extraSpeakers]});
}
function undo(file) {
  if (!undoStack[file].length) return;
  redoStack[file].push(snapshot(file));
  restore(file, undoStack[file].pop());
  afterEdit(file, true);
}
function redo(file) {
  if (!redoStack[file].length) return;
  undoStack[file].push(snapshot(file));
  restore(file, redoStack[file].pop());
  afterEdit(file, true);
}
// after any data mutation: mark dirty, recompute diff, redraw
function afterEdit(file, checkSelection) {
  dirty[file] = true;
  if (checkSelection && selected && selected.file === file &&
      !findSeg(file, selected.id)) deselectSeg();
  computeDiff();
  render();
  refreshEditbar();
}
function lastEditedFile() {
  return selected ? selected.file : null;
}

function selectSeg(file, id) {
  selected = {file, id};
  document.querySelectorAll('.seg.selected')
      .forEach(e => e.classList.remove('selected'));
  const el = document.querySelector(
      `.seg[data-file="${file}"][data-seg-id="${id}"]`);
  if (el) el.classList.add('selected');
  refreshEditbar();
}
function deselectSeg() {
  selected = null;
  document.querySelectorAll('.seg.selected')
      .forEach(e => e.classList.remove('selected'));
  refreshEditbar();
}
function refreshEditbar() {
  const bar = $('editbar');
  if (!selected) { bar.style.display = 'none'; return; }
  const s = findSeg(selected.file, selected.id);
  if (!s) { bar.style.display = 'none'; return; }
  bar.style.display = 'flex';
  $('ebtitle').textContent =
      `${NAME[selected.file]} · ${s.speaker}`;
  $('ebspk').value = s.speaker;
  $('ebstart').value = s.start.toFixed(3);
  $('ebend').value = s.end.toFixed(3);
  $('ebdur').textContent = `(${(s.end - s.start).toFixed(2)}s)`;
  const dl = $('spklist');
  dl.innerHTML = '';
  for (const spk of laneOrder(selected.file)) {
    const o = document.createElement('option');
    o.value = spk;
    dl.appendChild(o);
  }
}
function applyEditbar() {
  if (!selected) return;
  const s = findSeg(selected.file, selected.id);
  const start = parseTime($('ebstart').value);
  const end = parseTime($('ebend').value);
  const spk = $('ebspk').value.trim();
  if (start === null || end === null || !spk ||
      start < 0 || end <= start || start >= dur) {
    $('ebdur').textContent = '(无效输入)';
    return;
  }
  pushUndo(selected.file);
  s.start = start; s.end = Math.min(end, dur); s.speaker = spk;
  afterEdit(selected.file);
}
function splitSelected() {
  if (!selected) return;
  const s = findSeg(selected.file, selected.id);
  const t = audio.currentTime;
  if (t <= s.start + 0.02 || t >= s.end - 0.02) {
    $('ebdur').textContent = '(播放头不在段内,无法拆分)';
    return;
  }
  pushUndo(selected.file);
  const right = {id: nextId++, start: t, end: s.end, speaker: s.speaker};
  s.end = t;
  meta.files[selected.file].segments.push(right);
  afterEdit(selected.file);
}
function deleteSelected() {
  if (!selected) return;
  const f = meta.files[selected.file];
  pushUndo(selected.file);
  f.segments = f.segments.filter(s => s.id !== selected.id);
  const file = selected.file;
  deselectSeg();
  afterEdit(file);
}
function addSegFromSel(file, spk) {
  if (!sel) {
    $('selinfo').innerHTML =
        '<span style="color:#ff7070">先拖动选择一个区间,再点 +段</span>';
    return;
  }
  pushUndo(file);
  const s = {id: nextId++, start: sel.start, end: sel.end, speaker: spk};
  meta.files[file].segments.push(s);
  afterEdit(file);
  selectSeg(file, s.id);
}
function addSpeaker(file) {
  const name = prompt('新说话人标签(仅用于本页;保存时无段的说话人不会写入 RTTM):');
  if (!name || !name.trim()) return;
  meta.files[file].extraSpeakers.add(name.trim());
  render();
}

/* ---------- mouse interactions on tracks ---------- */

const tracksEl = $('tracks');
tracksEl.addEventListener('mousedown', ev => {
  const segEl = ev.target.closest('.seg');
  if (segEl) {
    const file = segEl.dataset.file, id = +segEl.dataset.segId;
    const r = segEl.getBoundingClientRect();
    const x = ev.clientX - r.left;
    const edge = Math.min(6, r.width / 3);
    const mode = r.width >= 12 && x < edge ? 'resize-l'
               : r.width >= 12 && x > r.width - edge ? 'resize-r' : 'move';
    const s = findSeg(file, id);
    dragging = {mode, file, id, el: segEl, moved: false, pushed: false,
                grabOffset: xToTime(ev.clientX) - s.start};
    ev.preventDefault();
    return;
  }
  const diffEl = ev.target.closest('.diffseg');
  if (diffEl) {
    dragging = {mode: 'select', anchor: xToTime(ev.clientX), moved: false,
                diffEl};
    ev.preventDefault();
    return;
  }
  const lane = ev.target.closest('.lane');
  if (ev.altKey && lane) {
    dragging = {mode: 'create', file: lane.dataset.file,
                spk: lane.dataset.speaker, lane,
                anchor: xToTime(ev.clientX), t0: null, t1: null,
                el: null, moved: false};
    ev.preventDefault();
    return;
  }
  dragging = {mode: 'select', anchor: xToTime(ev.clientX), moved: false};
  ev.preventDefault();
});

window.addEventListener('mousemove', ev => {
  if (!dragging) return;
  const t = xToTime(ev.clientX);
  const pps = pxPerSec();
  if (dragging.mode === 'select') {
    if (Math.abs(t - dragging.anchor) * pps > 3) {
      dragging.moved = true;
      setSel(dragging.anchor, t);
    }
  } else if (dragging.mode === 'create') {
    if (Math.abs(t - dragging.anchor) * pps > 3) {
      dragging.moved = true;
      dragging.t0 = Math.min(dragging.anchor, t);
      dragging.t1 = Math.max(dragging.anchor, t);
      if (!dragging.el) {
        dragging.el = document.createElement('div');
        dragging.el.className = 'seg';
        dragging.el.style.background =
            colorFor(dragging.file, dragging.spk);
        dragging.el.style.opacity = '0.6';
        dragging.lane.appendChild(dragging.el);
      }
      dragging.el.style.left = tX(dragging.t0) + 'px';
      dragging.el.style.width = Math.max(2, (dragging.t1-dragging.t0)*pps) + 'px';
    }
  } else {  // move / resize
    const s = findSeg(dragging.file, dragging.id);
    if (!s) { dragging = null; return; }
    if (!dragging.pushed) { pushUndo(dragging.file); dragging.pushed = true; }
    dragging.moved = true;
    if (dragging.mode === 'move') {
      const len = s.end - s.start;
      const ns = Math.min(Math.max(t - dragging.grabOffset, 0), dur - len);
      s.start = ns; s.end = ns + len;
    } else if (dragging.mode === 'resize-l') {
      s.start = Math.min(Math.max(t, 0), s.end - 0.02);
    } else {
      s.end = Math.max(Math.min(t, dur), s.start + 0.02);
    }
    dragging.el.style.left = tX(s.start) + 'px';
    dragging.el.style.width = Math.max(2, (s.end-s.start)*pps) + 'px';
    if (selected && selected.file === dragging.file &&
        selected.id === dragging.id) {
      $('ebstart').value = s.start.toFixed(3);
      $('ebend').value = s.end.toFixed(3);
      $('ebdur').textContent = `(${(s.end - s.start).toFixed(2)}s)`;
    }
  }
});

window.addEventListener('mouseup', ev => {
  if (!dragging) return;
  const d = dragging;
  dragging = null;
  if (d.mode === 'select') {
    if (!d.moved) {
      if (d.diffEl) {  // click on a diff region: select it and play
        setSel(+d.diffEl.dataset.t0, +d.diffEl.dataset.t1);
        playSel();
      } else {
        audio.currentTime = xToTime(ev.clientX);
      }
    }
  } else if (d.mode === 'create') {
    if (d.el) d.el.remove();
    if (d.moved && d.t1 - d.t0 >= 0.05) {
      pushUndo(d.file);
      const s = {id: nextId++, start: d.t0, end: d.t1, speaker: d.spk};
      meta.files[d.file].segments.push(s);
      afterEdit(d.file);
      selectSeg(d.file, s.id);
    }
  } else {  // move / resize finished (or plain click on a segment)
    if (d.moved) {
      afterEdit(d.file);
      selectSeg(d.file, d.id);
    } else {
      selectSeg(d.file, d.id);
    }
  }
});

tracksEl.addEventListener('dblclick', ev => {
  const segEl = ev.target.closest('.seg');
  if (!segEl) return;
  const s = findSeg(segEl.dataset.file, +segEl.dataset.segId);
  if (s) { setSel(s.start, s.end); playSel(); }
});

// lane-label "+seg" / panel "+speaker" buttons (delegated)
$('lanes').addEventListener('click', ev => {
  const t = ev.target;
  if (t.dataset && 'addseg' in t.dataset) {
    const lane = t.closest('.lane');
    addSegFromSel(lane.dataset.file, lane.dataset.speaker);
  } else if (t.dataset && t.dataset.addspk) {
    addSpeaker(t.dataset.addspk);
  }
});

/* ---------- save ---------- */

async function save(which) {
  const f = meta.files[which];
  $('savemsg').textContent = '保存中…';
  try {
    const r = await fetch('/api/save', {
      method: 'POST',
      headers: {'Content-Type': 'application/json'},
      body: JSON.stringify({which, index: meta.index, segments: f.segments.map(
          ({start, end, speaker}) => ({start, end, speaker}))}),
    });
    if (!r.ok) throw new Error(await r.text());
    const res = await r.json();
    dirty[which] = false;
    updateSaveBtns();
    $('savemsg').textContent = `已保存 ${res.n} 段 → ${res.path}`;
  } catch (e) {
    $('savemsg').textContent = '';
    $('err').textContent = '保存失败: ' + e;
    $('err').style.display = 'block';
  }
}
$('savegt').onclick = () => save('gt');
$('savea').onclick = () => save('a');
$('saveb').onclick = () => save('b');
window.addEventListener('beforeunload', ev => {
  if (fileKeys.some(k => dirty[k])) { ev.preventDefault(); ev.returnValue = ''; }
});

/* ---------- item navigation ---------- */

function confirmLeave() {
  if (!fileKeys.some(k => dirty[k])) return true;
  return confirm('当前条目有未保存的修改,切换后将丢失。确定切换?');
}

async function loadItem(idx) {
  if (meta && (idx < 0 || idx >= meta.n_items)) return;
  if (meta && idx === meta.index) return;
  if (meta && !confirmLeave()) {
    $('itemidx').value = meta.index;
    return;
  }
  $('err').style.display = 'none';
  let m;
  try {
    const r = await fetch('/api/meta/' + idx);
    if (!r.ok) throw new Error(await r.text());
    m = await r.json();
  } catch (e) {
    $('err').textContent = '加载失败: ' + e;
    $('err').style.display = 'block';
    return;
  }
  // reset all per-item state
  meta = {index: m.index, n_items: m.n_items, dataset: m.dataset, id: m.id,
          audio_file: m.audio_file, duration: m.duration, files: m.files};
  fileKeys = ALL_KEYS.filter(k => meta.files[k]);
  nextId = 1;
  undoStack = {}; redoStack = {}; dirty = {};
  for (const file of fileKeys) {
    const f = meta.files[file];
    f.extraSpeakers = new Set();
    f.segments.forEach(s => { s.id = nextId++; });
    undoStack[file] = []; redoStack[file] = []; dirty[file] = false;
  }
  const prevPair = diffPair;
  diffPair = prevPair && fileKeys.includes(prevPair[0]) &&
             fileKeys.includes(prevPair[1])
      ? prevPair : pairCombos()[0];
  selected = null;
  dur = meta.duration;
  clearSel();
  $('savemsg').textContent = '';
  audio.src = '/api/audio/' + idx;
  $('itemidx').value = idx;
  $('itemidx').max = meta.n_items - 1;
  $('itemcount').textContent = '/ ' + (meta.n_items - 1);
  $('previtem').disabled = idx === 0;
  $('nextitem').disabled = idx === meta.n_items - 1;
  $('fname').textContent = `${meta.dataset} / ${meta.audio_file}` +
      fileKeys.map(k => ` · ${NAME[k]}=${meta.files[k].rttm_file}`).join('');
  document.title = `批量多 RTTM 对比 – ${meta.dataset}/${meta.id}`;
  computeMapping();
  updateDiffPairSelect();
  computeDiff();
  render();
  refreshEditbar();
}

$('previtem').onclick = () => loadItem(meta.index - 1);
$('nextitem').onclick = () => loadItem(meta.index + 1);
$('itemidx').onchange = () => loadItem(parseInt($('itemidx').value || 0));

/* ---------- top-level controls & keys ---------- */

$('zoom').oninput = () => {
  zoomFactor = Math.pow(2, $('zoom').value / 12.5);  // 1x .. 256x
  $('zoomval').textContent = zoomFactor < 10 ?
      zoomFactor.toFixed(1)+'×' : Math.round(zoomFactor)+'×';
  render();
};
$('playsel').onclick = playSel;
$('clearsel').onclick = clearSel;
$('applysel').onclick = applyManualSel;
$('mindiff').oninput = () => render();
$('diffpair').onchange = () => {
  diffPair = $('diffpair').value.split('|');
  computeDiff();
  render();
};
$('remap').onclick = () => { computeMapping(); computeDiff(); render(); };
$('ebapply').onclick = applyEditbar;
$('ebplay').onclick = () => {
  if (!selected) return;
  const s = findSeg(selected.file, selected.id);
  if (s) { setSel(s.start, s.end); playSel(); }
};
$('ebsplit').onclick = splitSelected;
$('ebdel').onclick = deleteSelected;
$('ebclose').onclick = deselectSeg;
['selstart', 'selend'].forEach(id => $(id).addEventListener('keydown',
  ev => { if (ev.key === 'Enter') applyManualSel(); }));
['ebspk', 'ebstart', 'ebend'].forEach(id => $(id).addEventListener('keydown',
  ev => { if (ev.key === 'Enter') applyEditbar(); }));

document.addEventListener('keydown', ev => {
  const typing = ev.target.tagName === 'INPUT' &&
                 ev.target.type !== 'checkbox' &&
                 ev.target.type !== 'range';
  if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'z') {
    ev.preventDefault();
    const f = lastEditedFile() ||
        fileKeys.find(k => undoStack[k] && undoStack[k].length) || null;
    if (f) ev.shiftKey ? redo(f) : undo(f);
    return;
  }
  if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'y') {
    ev.preventDefault();
    const f = lastEditedFile() ||
        fileKeys.find(k => redoStack[k] && redoStack[k].length) || null;
    if (f) redo(f);
    return;
  }
  if (ev.key === 'PageUp') { ev.preventDefault(); loadItem(meta.index - 1); return; }
  if (ev.key === 'PageDown') { ev.preventDefault(); loadItem(meta.index + 1); return; }
  if (typing) return;
  const jump = ev.shiftKey ? 0.5 : 5;
  if (ev.key === 'ArrowLeft')
    audio.currentTime = Math.max(0, audio.currentTime - jump);
  else if (ev.key === 'ArrowRight')
    audio.currentTime = Math.min(dur, audio.currentTime + jump);
  else if (ev.key === 'Escape') selected ? deselectSeg() : clearSel();
  else if (ev.key === 'Delete' || ev.key === 'Backspace') deleteSelected();
  else if (ev.key.toLowerCase() === 's') splitSelected();
  else if (ev.key === ' ') { ev.preventDefault();
    audio.paused ? audio.play() : audio.pause(); }
});
window.addEventListener('resize', render);

// non-WAV audio: the server may only estimate the duration from the last
// segment end, so refine it once the browser has decoded the metadata
audio.addEventListener('loadedmetadata', () => {
  if (isFinite(audio.duration) && Math.abs(audio.duration - dur) > 0.05) {
    dur = audio.duration;
    render();
  }
});

loadItem(0);
</script>
</body>
</html>
"""


class Handler(BaseHTTPRequestHandler):
    store = None

    def log_message(self, *args):
        pass

    def _send(self, code, body, ctype="application/json", extra=None):
        self.send_response(code)
        self.send_header("Content-Type", ctype)
        self.send_header("Content-Length", str(len(body)))
        for k, v in (extra or {}).items():
            self.send_header(k, v)
        self.end_headers()
        self.wfile.write(body)

    def do_GET(self):
        try:
            self._route()
        except BrokenPipeError:
            pass
        except IndexError:
            self._send(404, b"item index out of range", "text/plain")
        except Exception as e:  # surface errors to the page
            self._send(500, str(e).encode(), "text/plain; charset=utf-8")

    def do_POST(self):
        try:
            if self.path == "/api/save":
                length = int(self.headers.get("Content-Length", 0))
                payload = json.loads(self.rfile.read(length))
                path, n = self.store.save(int(payload["index"]),
                                          payload["which"],
                                          payload["segments"])
                self._send(200, json.dumps({"path": path, "n": n}).encode())
            else:
                self._send(404, b"not found", "text/plain")
        except BrokenPipeError:
            pass
        except Exception as e:
            self._send(500, str(e).encode(), "text/plain; charset=utf-8")

    def _route(self):
        if self.path in ("/", "/index.html"):
            self._send(200, PAGE.encode(), "text/html; charset=utf-8")
        elif m := re.fullmatch(r"/api/meta/(\d+)", self.path):
            self._send(200, json.dumps(self.store.meta(int(m.group(1)))).encode())
        elif m := re.fullmatch(r"/api/audio/(\d+)", self.path):
            data, ctype, _ = self.store.audio(int(m.group(1)))
            self._serve_audio(data, ctype)
        else:
            self._send(404, b"not found", "text/plain")

    def _serve_audio(self, data, ctype):
        """Serve audio bytes with Range support so the player can seek."""
        rng = self.headers.get("Range")
        total = len(data)
        if rng and (m := re.fullmatch(r"bytes=(\d*)-(\d*)", rng.strip())):
            start = int(m.group(1)) if m.group(1) else 0
            end = int(m.group(2)) if m.group(2) else total - 1
            end = min(end, total - 1)
            if start > end:
                self._send(416, b"", ctype,
                           {"Content-Range": f"bytes */{total}"})
                return
            chunk = data[start:end + 1]
            self._send(206, chunk, ctype, {
                "Content-Range": f"bytes {start}-{end}/{total}",
                "Accept-Ranges": "bytes"})
        else:
            self._send(200, data, ctype, {"Accept-Ranges": "bytes"})


def main():
    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
    ap.add_argument("experiment_dir",
                    help="directory whose sub-dirs hold <id>.wav + <id>.rttm "
                         "+ <id>_3D.rttm [+ <id>_GT.rttm] items")
    ap.add_argument("--port", type=int, default=8766)
    ap.add_argument("--host", default="127.0.0.1")
    args = ap.parse_args()

    items = scan_items(args.experiment_dir)
    if not items:
        raise SystemExit(f"no complete items found under {args.experiment_dir}")

    n_gt = sum(1 for it in items if "gt" in it)
    Handler.store = ItemStore(items)
    srv = ThreadingHTTPServer((args.host, args.port), Handler)
    print(f"Serving {len(items)} items ({n_gt} with GT) from "
          f"{args.experiment_dir} at http://{args.host}:{args.port}")
    for i, it in enumerate(items[:10]):
        print(f"  [{i}] {it['dataset']}/{it['id']}"
              f"{'' if 'gt' in it else '  (no GT)'}")
    if len(items) > 10:
        print(f"  ... and {len(items) - 10} more")
    try:
        srv.serve_forever()
    except KeyboardInterrupt:
        pass


if __name__ == "__main__":
    main()