# -*- coding: utf-8 -*-
"""一次性迁移：四个 XToY 目录 → 统一 data/ 平铺布局（2026-10-19）。

旧布局：WordTranslation/{EnToX,XToEn,ZhToX,XToZh}/data/<src>_<dst>.jsonl.gz
新布局：WordTranslation/data/<src>_<dst>.jsonl.gz（每个方向唯一一份，方向在文件名里）

顺手修掉旧 pack 产物的三个 gzip/换行问题：
  * FNAME 被写成 "<name>.jsonl.gz.tmp"（用 7-Zip / gunzip -N 解压后后缀错乱）
  * MTIME 每次不同（rebuild 非确定）
  * 正文全是 CRLF（Windows 文本模式写出的），与 Linux 重建产物不一致 → 统一 LF
做法是逐文件「解压→按正确头重压」：**除 CRLF→LF 外，JSONL 内容逐字节不变**。
（wt.py 的 pack 已同步修好，今后新产物不会再犯。）

en⇄zh 只在两套管线各产一份、字节不同；沿用网站消费端（init_web.js）的口径保留
  en_zh ← XToZh 管线，zh_en ← XToEn 管线，另一份进 build/dupes/ 留档。
构建输入（cache/llm/manual）归入 build/<pair>/，与正向目录完全相同的副本去重丢弃。

可重复执行：若 data/ 已是新布局，自动只做「换行归一 + 重建 sidecar」。

用法：python tools/migrate_flat_layout.py [--dry-run]
"""
import gzip
import hashlib
import json
import os
import shutil
import sys
from datetime import datetime
from pathlib import Path

HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
import wt  # noqa: E402

WT = wt.WT
DATA = wt.DATA_DIR
OLD_DIRS = ("EnToX", "XToEn", "ZhToX", "XToZh")
LEGACY = WT / "build" / f"legacy-{datetime.now():%Y%m%d}"
DUPES = WT / "build" / "dupes"

# 扁平布局下 en⇄zh 各留一份：文件名 -> 取自哪个旧目录
KEEP_FROM = {"en_zh.jsonl.gz": "XToZh", "zh_en.jsonl.gz": "XToEn"}

# 构建输入搬迁：旧目录/子目录 -> build 下相对路径（None = 完全重复，去重丢弃）
BUILD_MAP = [
    ("EnToX", "cache", "en/cache"),
    ("EnToX", "llm", "en/llm"),
    ("EnToX", "manual", "en/manual"),
    ("EnToX", "raw", None),            # 空目录，丢弃
    ("XToEn", "cache", None),          # 与 EnToX/cache 逐字节相同
    ("XToEn", "llm", None),            # 与 EnToX/llm 逐字节相同
    ("XToEn", "manual", "en/manual-rev"),
    ("ZhToX", "cache", "zh/cache"),
    ("ZhToX", "llm", "zh/llm"),
    ("ZhToX", "manual", "zh/manual"),
    ("XToZh", "cache", None),          # 与 ZhToX/cache 逐字节相同
    ("XToZh", "llm", None),            # 与 ZhToX/llm 逐字节相同
    ("XToZh", "manual", "zh/manual-rev"),
]

DIRECTIONS = [
    ("en", "p1", "EnToX", "en"),
    ("en", "p2", "XToEn", None),
    ("zh", "p1", "ZhToX", "zh"),
    ("zh", "p2", "XToZh", None),
]

# 去重前先断言两份构建输入逐字节相同
DEDUP_CHECK = {
    ("XToEn", "cache"): "en/cache",
    ("XToEn", "llm"): "en/llm",
    ("XToZh", "cache"): "zh/cache",
    ("XToZh", "llm"): "zh/llm",
}

DRY = "--dry-run" in sys.argv

# 可选：旧布局备份根（内含 EnToX/XToEn/ZhToX/XToZh 四个目录），用于续跑时做逐字节比对
BACKUP = os.environ.get("WT_MIGRATE_BACKUP")


def sha256(b):
    return hashlib.sha256(b).hexdigest()


def gunzip_bytes(p):
    with gzip.open(p, "rb") as fh:
        return fh.read()


def normalize(data):
    """统一 LF 换行：旧产物在 Windows 文本模式下被写成了 CRLF（gzip.open(...,'wt') 的
    平台默认换行翻译），JSONL 语义不变，但平台间产物不一致。新 pack 一律 LF。"""
    if b"\r\n" in data:
        data = data.replace(b"\r\n", b"\n")
    return data


def write_gz(path, data):
    """写 gzip：不写 FNAME、mtime=0（确定性），与 wt.pack_one 同款。"""
    with open(path, "wb") as raw:
        with gzip.GzipFile(filename="", mode="wb", fileobj=raw,
                           compresslevel=9, mtime=0) as gz:
            gz.write(data)


def content_hashes(d):
    """dir -> {文件名: 归一化后 JSONL 内容的 sha256}（只看顶层，即 data 文件）"""
    out = {}
    d = Path(d)
    if not d.exists():
        return out
    for f in sorted(d.glob("*.jsonl.gz")):
        out[f.name] = sha256(normalize(gunzip_bytes(f)))
    return out


def normalize_data_files():
    """把 data/ 里仍是 CRLF 的文件就地重写为 LF（内容其余部分逐字节不变）。"""
    n = 0
    for f in sorted(DATA.glob("*.jsonl.gz")):
        raw = gunzip_bytes(f)
        norm = normalize(raw)
        if norm == raw:
            continue
        lines_before = raw.count(b"\n")
        if norm.count(b"\n") != lines_before:
            sys.exit(f"[迁移] {f.name} 换行归一后行数变了")
        write_gz(f, norm)
        n += 1
    print(f"[迁移] 换行归一：{n} 个文件 CRLF→LF（其余已是 LF）")


def dir_bytes_hashes(d):
    """dir -> {相对路径: 原始字节 sha256}（用于断言两份构建输入逐字节相同）"""
    out = {}
    d = Path(d)
    if not d.exists():
        return out
    for f in sorted(d.rglob("*")):
        if f.is_file():
            out[str(f.relative_to(d)).replace("\\", "/")] = sha256(f.read_bytes())
    return out


def read_old(dirpath):
    j = dirpath / "meta.json"
    meta = json.loads(j.read_text(encoding="utf-8")) if j.exists() else {}
    cards = {}
    for name in ("meta.json", "files.json", "README.md"):
        p = dirpath / name
        cards[name] = p.read_text(encoding="utf-8") if p.exists() else None
    return meta, cards


def main():
    # 已迁移则跳过搬迁（重跑只重建 sidecar，方便中断后续跑）
    resumed = DATA.exists() and any(DATA.glob("*.jsonl.gz"))

    old_metas, old_cards, root_readme = {}, {}, None
    pre = None
    if resumed:
        print(f"[迁移] 检测到 {DATA} 已是新布局 —— 跳过搬迁，只做换行归一 + 重建 sidecar/README")
        for d in OLD_DIRS:
            old_metas[d], _ = read_old(LEGACY / d)
        if not any(old_metas.values()):
            sys.exit(f"[迁移] 续跑需要旧 meta.json，但 {LEGACY} 里没有，无法重建 sidecar")
        if BACKUP:
            bp = Path(BACKUP)
            pre = {d: content_hashes(bp / d / "data") for d in OLD_DIRS}
            print(f"[迁移] 续跑比对基准：{bp}")
    else:
        print("[迁移] 读取旧 sidecar ...")
        for d in OLD_DIRS:
            old_metas[d], old_cards[d] = read_old(WT / d)
        root_readme = (WT / "README.md").read_text(encoding="utf-8")
        pre = {d: content_hashes(WT / d / "data") for d in OLD_DIRS}
        n_pre = sum(len(v) for v in pre.values())
        print(f"[迁移] 迁移前 data 文件共 {n_pre} 个（4×41 里有 2 个 en⇄zh 重复）")

    if DRY:
        print("[迁移] --dry-run：只做检查，不落盘。完成。")
        return

    if not resumed:
        print("[迁移] 归档旧 sidecar / 旧工作区 README ...")
        LEGACY.mkdir(parents=True, exist_ok=True)
        for d in OLD_DIRS:
            tgt = LEGACY / d
            tgt.mkdir(parents=True, exist_ok=True)
            for name, text in old_cards[d].items():
                if text is not None:
                    (tgt / name).write_text(text, encoding="utf-8")
        (LEGACY / "WORKSPACE_README.md").write_text(root_readme, encoding="utf-8")

        # --- 1) data 合并 + 去重 + 重压 ---
        DATA.mkdir(parents=True, exist_ok=True)
        DUPES.mkdir(parents=True, exist_ok=True)
        moved = duped = 0
        for d in OLD_DIRS:
            for f in sorted((WT / d / "data").glob("*.jsonl.gz")):
                keep_from = KEEP_FROM.get(f.name)
                if keep_from and keep_from != d:
                    shutil.move(str(f), str(DUPES / f"{d}_{f.name}"))
                    duped += 1
                    continue
                raw = gunzip_bytes(f)                   # 解压后的真实内容
                want = sha256(normalize(raw))
                write_gz(DATA / f.name, normalize(raw))  # 正确 gzip 头 + LF 重压
                got = sha256(normalize(gunzip_bytes(DATA / f.name)))
                if got != want:
                    sys.exit(f"[迁移] 校验失败：{f.name} 重压后内容变了")
                f.unlink()
                moved += 1
        print(f"[迁移] data/ 落盘 {moved} 个文件，另有 {duped} 个 en⇄zh 重复件归档到 build/dupes/")

        # --- 2) 构建输入搬迁 ---
        for old_dir, sub, rel in BUILD_MAP:
            src = WT / old_dir / sub
            if not src.exists():
                continue
            if rel is None:
                if (old_dir, sub) in DEDUP_CHECK:
                    ref = WT / "build" / DEDUP_CHECK[(old_dir, sub)]
                    a, b = dir_bytes_hashes(src), dir_bytes_hashes(ref)
                    if a != b:
                        sys.exit(f"[迁移] {old_dir}/{sub} 与 build/{DEDUP_CHECK[(old_dir, sub)]} "
                                 f"并不相同，不能去重")
                    print(f"[迁移] 去重丢弃 {old_dir}/{sub}"
                          f"（与 build/{DEDUP_CHECK[(old_dir, sub)]} 逐字节相同）")
                else:
                    print(f"[迁移] 丢弃空的 {old_dir}/{sub}")
                    if any(src.rglob("*")):
                        sys.exit(f"[迁移] {old_dir}/{sub} 非空，不能按空目录处理")
                shutil.rmtree(src)
                continue
            dst = WT / "build" / rel
            dst.parent.mkdir(parents=True, exist_ok=True)
            if dst.exists():
                sys.exit(f"[迁移] 目标已存在：{dst}")
            shutil.move(str(src), str(dst))
            print(f"[迁移] {old_dir}/{sub} → build/{rel}")

        # --- 3) 旧目录里剩的就只有已归档的 sidecar 了，确认后删掉 ---
        for d in OLD_DIRS:
            for name in ("meta.json", "files.json", "README.md"):
                p = WT / d / name
                if p.exists():
                    p.unlink()      # 已归档到 LEGACY/，见上
            left = [p for p in (WT / d).rglob("*") if p.is_file()]
            if left:
                sys.exit(f"[迁移] {d} 仍有未处理文件：{left[:5]}")
            shutil.rmtree(WT / d)
        print("[迁移] 旧 XToY 目录已移除")

    # --- 4) 换行归一（两种模式都跑；旧产物全是 Windows 文本模式写出的 CRLF） ---
    normalize_data_files()

    # --- 5) 统一 meta + files + README ---
    meta = {
        "version": 2,
        "generatedAt": wt.local_iso(),
        "dataset": "vocabradar/WordTranslation",
        "layout": "data/<src>_<dst>.jsonl.gz",
        "capPerWord": wt.CAP_PER_WORD,
        "directions": {},
    }
    for pair, pass_name, dir_name, _ in DIRECTIONS:
        old = old_metas[dir_name]
        langs = wt.recount(pass_name, pair)          # 按现存文件重算，保证与产物一致
        if pass_name == "p2":
            # 覆盖率分母 = 各语言 small_<code> 词表；沿用旧 meta 的 vocabSize（免读 wordfreq）
            for code, st in langs.items():
                st["vocabSize"] = (old.get("languages", {}).get(code, {})
                                   .get("vocabSize") or 0)
        meta["directions"][dir_name] = {
            "source": old.get("source", {}),
            "vocabulary": old.get("vocabulary", {}),
            "languages": langs,
        }
        print(f"[迁移] {dir_name}: {len(langs)} 语")
    (WT / "meta.json").write_text(json.dumps(meta, ensure_ascii=False, indent=2) + "\n",
                                  encoding="utf-8")
    wt.write_files_json()
    wt.write_readme(meta)

    # --- 6) 总校验：唯一的 data/ 覆盖全部 162 个方向 ---
    final = content_hashes(DATA)
    if len(final) != 162:
        sys.exit(f"[迁移] data/ 实际 {len(final)} 个文件，期望 162")
    if pre is None:
        print(f"[迁移] 校验：data/ = {len(final)} 个唯一方向"
              f"（未提供 WT_MIGRATE_BACKUP，未做逐字节比对）")
    else:
        kept = {}
        for d in OLD_DIRS:
            for name, h in pre[d].items():
                keep_from = KEEP_FROM.get(name)
                if keep_from is not None and keep_from != d:
                    continue                     # 被归档的那一份
                kept[name] = h
        if len(kept) != 162:
            sys.exit(f"[迁移] 期望 162 个唯一方向，实得 {len(kept)}")
        bad = sorted(n for n, h in kept.items() if final.get(n) != h)
        if bad:
            sys.exit(f"[迁移] 内容校验失败（{len(bad)} 个）：{bad[:5]}")
        print(f"[迁移] 校验通过：data/ = {len(final)} 个唯一方向"
              f"（换行符归一外，内容与迁移前逐字节一致）")
    print(f"[迁移] 完成。旧 sidecar / 旧 README 存于 {LEGACY}")


if __name__ == "__main__":
    main()