#!/usr/bin/env python3
"""teach_state_rate.py — 手教示の記録 (record_teach_demo.py run --execute) の実測角の間隔を, 直す前と後の本で並べる
(2026-11-15 依頼 202. 数え方は依頼 197 の KIOXIA diag/teach_state_rate_20261115/measure_gaps.py と同じ).

依頼 202 で, 電流の記録スレッド (read_servo) が読んだ角度も states.csv の actual 行に書くようにした
(note 列が source=current_thread. 本体の読み = 到達・静止の確かめなどは note が空のまま). 実機で 1 本 → 5 本撮って,
  - states.csv の actual の間隔 (全部・本体の読みだけ・電流スレッドの読みだけ) の中央値・90% 点・1 秒超
  - 間の原因ごと (poll = 到達・静止の確かめの間 / send = 送信の待ち / gripper = 爪の待ち / stage_change)
  - 試行 JSON の segments: 動く区間ごとの送信の往復 (send_rtt_sec)・区間の長さ (segment_elapsed_sec)・再送・着いたか,
    爪の前の静止の確かめ (still_check の reads・elapsed_sec・still)
が直す前の本と同じ形かを見る. 合否の線は決めていない (表を出すだけ).
依頼 225: 本ごとに, 撮った形 (待ち. split は daemon と Mac の秒数)・送信が無視された回 (無視 = 到達の待ちが切れて
1.0° 未満で再送した回. うち 0.00°・そのときの角度)・daemon の送信のあとの読みが返事なしだった見込みの回数
(試行 JSON の daemon_read_none_suspects. daemon.log の数そのものではない)・daemon だけの往復の中央と最大も出す.

入力: {runs_root}/{run}/{run}.json と {run}/recording/states.csv (runs_root の既定は KIOXIA の runs/run_pick_place)
  python3 pi05/teach_state_rate.py --before run_0001_20261109_094839 run_0001_20261109_095308 --after run_0001_20261116_...
  python3 pi05/teach_state_rate.py --after /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261116_...   # フォルダでも
  python3 pi05/teach_state_rate.py --before ... --after ... --out    # CSV も残す
--out のときだけ書く: /Volumes/KIOXIA/r2r2r-data/runs/experiments/teach_state_rate/{YYYYMMDD_HHMMSS}/
  runs.csv (本ごと)・segments.csv (区間ごと). KIOXIA がなければ止まる. 出し先がもうあれば止まる. run の記録には何も書かない.
"""
import argparse
import csv
import json
import os
import statistics
import sys
from datetime import datetime
from pathlib import Path

KIOXIA_MOUNT = Path("/Volumes/KIOXIA")
DATA_ROOT = KIOXIA_MOUNT / "r2r2r-data"
RUNS_ROOT = DATA_ROOT / "runs" / "run_pick_place"
OUT_ROOT = DATA_ROOT / "runs" / "experiments" / "teach_state_rate"
CURRENT_THREAD_NOTE = "source=current_thread"   # record_teach_demo.CURRENT_THREAD_NOTE と同じ
LONG = 1.0


def ensure_ssd_mounted():
    """KIOXIA がマウントされていて書けるか. だめなら止める (ローカルへは書かない)."""
    if not os.path.ismount(str(KIOXIA_MOUNT)):
        sys.exit(f"[ABORT] KIOXIA がマウントされていません: {KIOXIA_MOUNT}")
    if not DATA_ROOT.is_dir():
        sys.exit(f"[ABORT] {DATA_ROOT} がありません")


def run_dir(arg, runs_root):
    p = Path(arg)
    return p if p.is_dir() else Path(runs_root) / arg


def load_states(path):
    rows = []
    with Path(path).open(newline="") as f:
        for r in csv.DictReader(f):
            try:
                r["ts"] = float(r["ts"])
            except (KeyError, TypeError, ValueError):
                continue
            rows.append(r)
    return rows


def is_actual(r):
    return r.get("event_type") == "actual" and (r.get("j0") or "") != ""


def source_of(r):
    return "current_thread" if CURRENT_THREAD_NOTE in (r.get("note") or "").split() else "main"


def classify(rows):
    """actual の間ごとに原因を決める (依頼 197 の measure_gaps.classify と同じ決め方. 手教示の形).
    rows は states.csv の行 (stage・gripper_cmd も入ったまま)."""
    acts = [i for i, r in enumerate(rows) if is_actual(r)]
    out = []
    for a, b in zip(acts, acts[1:]):
        types = [m.get("event_type") for m in rows[a + 1:b]]
        prev = rows[a - 1].get("event_type") if a > 0 else ""
        if "gripper_cmd" in types or "gripper" in types:
            cause = "gripper"
        elif "commanded" in types or prev == "stage":
            cause = "send"          # record_teach_demo: stage → 送信前の読み → 送信 (wait=1.0)
        elif "stage" in types:
            cause = "stage_change"
        else:
            cause = "poll"
        out.append({"t0": rows[a]["ts"], "t1": rows[b]["ts"], "gap": rows[b]["ts"] - rows[a]["ts"],
                    "stage": rows[a].get("stage"), "cause": cause})
    return out


def pct(v, p):
    if not v:
        return None
    ys = sorted(v)
    k = (len(ys) - 1) * p / 100.0
    lo = int(k)
    hi = min(lo + 1, len(ys) - 1)
    return ys[lo] + (ys[hi] - ys[lo]) * (k - lo)


def gap_stats(gaps):
    v = [g["gap"] for g in gaps]
    tot = sum(v)
    lv = [x for x in v if x > LONG]
    return {"n": len(v), "median": pct(v, 50), "p90": pct(v, 90), "max": max(v) if v else None,
            "long_n": len(lv), "long_share": (sum(lv) / tot) if tot > 0 else None}


def order_ok(rows):
    """states.csv の行が時刻順に並んでいるか (依頼 202). 逆になった所の数."""
    return sum(1 for a, b in zip(rows, rows[1:]) if b["ts"] < a["ts"])


def measure(d):
    """1 本の値 (dict) と区間ごとの行 (list)."""
    d = Path(d)
    name = d.name
    rows = load_states(d / "recording" / "states.csv")
    acts = [r for r in rows if is_actual(r)]
    main_rows = [r for r in rows if not (is_actual(r) and source_of(r) == "current_thread")]
    g_all = classify(rows)
    g_main = classify(main_rows)
    cur_ts = [r["ts"] for r in acts if source_of(r) == "current_thread"]
    g_cur = [{"gap": b - a} for a, b in zip(cur_ts, cur_ts[1:])]
    out = {"run": name, "n_actual": len(acts), "n_main": len(acts) - len(cur_ts), "n_current_thread": len(cur_ts),
           "order_reversed": order_ok(rows)}
    for key, g in (("all", g_all), ("main", g_main), ("cur", g_cur)):
        s = gap_stats(g)
        for k, v in s.items():
            out[f"{key}_{k}"] = v
    for cause in ("poll", "send", "gripper"):
        s = gap_stats([g for g in g_all if g["cause"] == cause])
        out[f"all_{cause}_median"], out[f"all_{cause}_max"] = s["median"], s["max"]
    try:
        j = json.loads((d / f"{name}.json").read_text())
    except Exception as e:
        j = {}
        out["json_error"] = f"{type(e).__name__}"
    cur = j.get("currents") or {}
    out.update({"result": j.get("result"), "overruns": cur.get("overruns"),
                # 依頼 213: 送信のあとの 1.0 秒をどこで待ったか (mac / daemon. 依頼 213 より前の本は項目がないので -)
                "send_wait_on": j.get("send_wait_on"),
                "sent_current_thread": j.get("recorder_actual_events_sent_current_thread"),
                "late_current_thread": j.get("recorder_actual_current_thread_late"),
                "actual_sampling_reads_ok": (j.get("actual_sampling") or {}).get("reads_ok")})
    segs = []
    for g in j.get("segments") or []:
        sc = g.get("still_check") or {}
        segs.append({"run": name, "step": g.get("step"), "kind": g.get("kind"),
                     "name": g.get("to_name") if g.get("kind") == "move" else g.get("action"),
                     "send_rtt_sec": g.get("send_rtt_sec"), "segment_elapsed_sec": g.get("segment_elapsed_sec"),
                     "send_daemon_rtt_sec": g.get("send_daemon_rtt_sec"),   # 依頼 213: daemon とのやりとりだけ
                     "retried": g.get("retried"), "arrival_ok": g.get("arrival_ok"),
                     "retry_move_deg": g.get("retry_move_deg"),   # 依頼 225: 再送したときの動いた角度
                     "still_reads": sc.get("reads"), "still_elapsed_sec": sc.get("elapsed_sec"),
                     "still": sc.get("still")})
    out["still_reads_total"] = sum(s["still_reads"] or 0 for s in segs)
    out["retried_n"] = sum(1 for s in segs if s["retried"])
    # 依頼 225: 撮った形 (split は daemon と Mac の秒数も)・送信が無視された回・daemon の読みが返事なしの見込み
    out["send_wait"] = wait_label(j)
    ig = j.get("send_ignored")
    if isinstance(ig, dict):
        out["ignored_n"], out["ignored_zero_n"] = ig.get("count"), ig.get("zero_move_count")
        moves = [e.get("retry_move_deg") for e in ig.get("events") or []]
    else:   # 依頼 225 より前の本は区間の retried から数える (同じ決まり: 到達の待ちが切れて 1.0° 未満で再送)
        moves = [s["retry_move_deg"] for s in segs if s["retried"]]
        out["ignored_n"] = len(moves)
        out["ignored_zero_n"] = sum(1 for v in moves if isinstance(v, (int, float)) and abs(v) < 0.005)
    out["ignored_moves"] = " ".join(fmt(v, 2) for v in moves) or None
    ns = j.get("daemon_read_none_suspects")
    out["read_none_suspects"] = ns.get("suspects") if isinstance(ns, dict) else None
    rtts = [s["send_daemon_rtt_sec"] for s in segs
            if isinstance(s["send_daemon_rtt_sec"], (int, float)) and not isinstance(s["send_daemon_rtt_sec"], bool)]
    out["daemon_rtt_median"] = statistics.median(rtts) if rtts else None
    out["daemon_rtt_max"] = max(rtts) if rtts else None
    return out, segs


def wait_label(j):
    """依頼 225: 撮った形の表示. split は 'split 0.2+0.8'. 項目がない本 (依頼 213 より前) は None."""
    w = j.get("send_wait_on")
    if w == "split":
        return "split {:g}+{:g}".format(j.get("send_daemon_wait_sec") or 0, j.get("send_mac_wait_sec") or 0)
    return w


def fmt(v, nd=3):
    if v is None:
        return "-"
    if isinstance(v, float):
        return f"{v:.{nd}f}"
    return str(v)


RUN_COLS = [("run", "run"), ("n_actual", "actual"), ("n_current_thread", "うち電流"), ("all_median", "間 中央"),
            ("all_p90", "90%"), ("all_long_n", "1秒超"), ("all_poll_median", "poll中央"), ("all_send_median", "send中央"),
            ("main_median", "本体だけ中央"), ("main_p90", "本体90%"), ("cur_median", "電流だけ中央"),
            ("order_reversed", "逆順"), ("late_current_thread", "送らず"), ("overruns", "見込み超え"),
            ("still_reads_total", "静止reads"), ("retried_n", "再送"),
            ("ignored_n", "無視"), ("ignored_zero_n", "うち0.00°"), ("ignored_moves", "無視の角度"),
            ("read_none_suspects", "読みNone見込み"), ("daemon_rtt_median", "daemon往復中央"),
            ("daemon_rtt_max", "daemon往復最大"), ("send_wait", "待ち"), ("result", "結果")]


def print_group(label, ms):
    print(f"\n## {label} ({len(ms)} 本)")
    print("  " + " | ".join(h for _, h in RUN_COLS))
    for m in ms:
        print("  " + " | ".join(fmt(m.get(k)) for k, _ in RUN_COLS))
    if len(ms) > 1:
        def med(k):
            v = [m[k] for m in ms if isinstance(m.get(k), (int, float))]
            return statistics.median(v) if v else None
        print("  (本ごとの中央値) " + " | ".join(
            f"{h} {fmt(med(k))}" for k, h in RUN_COLS[1:] if k not in ("result", "send_wait", "ignored_moves")))


def print_segments(groups):
    """区間ごと (step 順) に, 群ごとの中央値を並べる. 区間の並びが群で違えば step の名前で分かる."""
    print("\n## 区間ごと (群ごとの中央値: 送信の往復 (待ちを含む) / daemon だけの往復 / 区間の長さ / 静止の確かめの reads)")
    keys = []
    for _, segs in groups:
        for s in segs:
            k = (s["step"], s["kind"], s["name"])
            if k not in keys:
                keys.append(k)
    for k in sorted(keys, key=lambda x: (x[0] is None, x[0] or 0)):
        cells = []
        for label, segs in groups:
            ss = [s for s in segs if (s["step"], s["kind"], s["name"]) == k]

            def med(f):
                v = [s[f] for s in ss if isinstance(s.get(f), (int, float)) and not isinstance(s.get(f), bool)]
                return statistics.median(v) if v else None
            cells.append(f"{label}: n={len(ss)} rtt {fmt(med('send_rtt_sec'))} daemon {fmt(med('send_daemon_rtt_sec'))}"
                         f" 長さ {fmt(med('segment_elapsed_sec'))}"
                         f" reads {fmt(med('still_reads'))}")
        print(f"  step {k[0]} {k[1]} {k[2]}  " + "  /  ".join(cells))


def write_out(results, segs_all):
    ensure_ssd_mounted()
    out = OUT_ROOT / datetime.now().strftime("%Y%m%d_%H%M%S")
    if out.exists():
        sys.exit(f"[ABORT] 出し先がもうあります: {out}")
    out.mkdir(parents=True)
    cols = sorted({k for r in results for k in r})
    cols = ["group"] + [c for c in cols if c != "group"]
    with (out / "runs.csv").open("w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=cols)
        w.writeheader()
        w.writerows(results)
    if segs_all:
        with (out / "segments.csv").open("w", newline="") as f:
            w = csv.DictWriter(f, fieldnames=list(segs_all[0].keys()))
            w.writeheader()
            w.writerows(segs_all)
    print(f"\n→ {out}")


def main(argv=None):
    ap = argparse.ArgumentParser(description="手教示の記録の実測角の間隔を直す前と後で並べる (依頼 202)")
    ap.add_argument("--before", nargs="*", default=[], help="直す前の run (名前かフォルダ)")
    ap.add_argument("--after", nargs="*", default=[], help="直したあとの run (名前かフォルダ)")
    ap.add_argument("--runs-root", default=str(RUNS_ROOT))
    ap.add_argument("--out", action="store_true", help="KIOXIA の runs/experiments/teach_state_rate/ に CSV も残す")
    a = ap.parse_args(argv)
    if not a.before and not a.after:
        ap.error("--before か --after に run を 1 本以上")
    results, groups, segs_all = [], [], []
    for label, names in (("before", a.before), ("after", a.after)):
        if not names:
            continue
        ms, ss = [], []
        for n in names:
            d = run_dir(n, a.runs_root)
            if not (d / "recording" / "states.csv").exists():
                sys.exit(f"[ABORT] states.csv がありません: {d}")
            m, segs = measure(d)
            m["group"] = label
            for s in segs:
                s["group"] = label
            ms.append(m)
            ss += segs
        print_group(label, ms)
        results += ms
        groups.append((label, ss))
        segs_all += ss
    print_segments(groups)
    if a.out:
        write_out(results, segs_all)
    return 0


if __name__ == "__main__":
    sys.exit(main())
