# -*- coding: utf-8 -*-
"""用**全新在线样本**做端到端重排测试（不需要真机明文，自证）。

做法:
  给每个语义名编一个**假值** value_i，按构建 A 的清单顺序排成 cd_A。
  再用锚点把它重排到构建 B 的顺序，得到 cd_B。
  正确答案 = 按 B 的清单顺序、取各自语义名的假值。

  这个测试能抓住 reorder 的核心 bug（恒等映射）：
  若 B 的顺序 ≠ A 的顺序，恒等映射必然错；只有真对齐才对。
"""
import glob
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / "tools"))
import tdc_collectgen as cg  # noqa: E402
import tdc_modules as tm  # noqa: E402

BATCH = sorted(glob.glob(str(ROOT / "har" / "online" / "*" / "tdc_*.js")))
print("新样本 %d 份" % len(BATCH))
print()


A = BATCH[0]
rowsA = tm.analyze(A)
namesA = [r["name"] for r in rowsA]
seqA = [r["module"] for r in rowsA]
n = len(namesA)
print("基准 %s  项 %d  唯一名 %d" % (A.split("/")[-1], n, len(set(namesA))))

# 假值：每项一个可区分的值
fake = {nm: "V<%s>" % nm for nm in namesA}
cd_A = [fake[nm] for nm in namesA]

src = cg.spec_from_seq(seqA, [None] * n, namesA, sample_cd=cd_A)

print()
for f in BATCH[1:]:
    rowsB = tm.analyze(f)
    namesB = [r["name"] for r in rowsB]
    seqB = [r["module"] for r in rowsB]
    dst = cg.spec_from_seq(seqB, [None] * len(rowsB), namesB)

    # 正确答案：按 B 的顺序取各自语义名的假值
    truth = [fake[nm] for nm in namesB]

    try:
        out = cg.reorder(cd_A, dst, src)
        ok = out == truth
        identical = out == cd_A
        print("  vs %-24s" % f.split("/")[-1])
        print("     重排结果 == 正确答案 : %s" % ok)
        print("     重排结果 == 原样(说明没重排): %s" % identical)
        if not ok:
            bad = [i for i, (a, b) in enumerate(zip(out, truth)) if a != b]
            print("     错位 %d 处, 前5: %s" % (len(bad), bad[:5]))
    except Exception as e:
        print("  vs %-24s %s: %s" % (f.split("/")[-1], type(e).__name__, str(e)[:110]))
    print()