#!/usr/bin/env python3
"""扫描现网路径与 book-index，生成中文/特殊路径 → ASCII slug 映射（不拷贝文件）。

默认 dry 输出到本目录 mapping/。用法（仓库根）：

  python tasks/data-platform/migration/01-build-mapping.py
  python tasks/data-platform/migration/01-build-mapping.py --dest-root E:/nginx-1.8.0/html
"""
from __future__ import annotations

import argparse
import csv
import json
import re
import sys
import unicodedata
from pathlib import Path

REPO = Path(__file__).resolve().parents[3]
DEFAULT_INDEX = REPO / "docs" / "data" / "book-index.json"
DEFAULT_OXFORD = Path(r"E:\BaiduNetdiskDownload\牛津树\牛津树1-14阶段PDF+音频")
DEFAULT_DEST = Path(r"E:\nginx-1.8.0\html")
OUT_DIR = Path(__file__).resolve().parent / "mapping"

_PUNCT = str.maketrans(
    {
        "’": "'",
        "‘": "'",
        "`": "'",
        "“": '"',
        "”": '"',
    }
)


def fs_slug(name: str) -> str:
    """目录/包 id 用 ASCII slug：去掉弯引号与撇号，其余危险字符变连字符。"""
    text = unicodedata.normalize("NFKC", name or "").translate(_PUNCT)
    text = text.replace("'", "")
    out: list[str] = []
    for ch in text:
        if ch.isalnum() or ch in "._-":
            out.append(ch)
        elif ch in " !?,#&+/\\":
            if out and out[-1] != "-":
                out.append("-")
    slug = "".join(out).strip(".-")
    return slug or "book"


def book_id(stage: str, img_folder: str) -> str:
    """逻辑 book_id = {stage}__{img_folder}，与 ort/events/key-words/01 schema 一致。

    物理目录用 fs_slug；二者只在撇号/标点书上不同，禁止用 slug 冒充 book_id。
    """
    return f"{stage}__{(img_folder or '').strip()}"


def needs_image_rewrite(img_folder: str) -> bool:
    return fs_slug(img_folder) != img_folder


def html_apostrophe(name: str) -> str:
    return name.replace("'", "&#39;")


def spaced_folder(name: str) -> str:
    return re.sub(r"(?<=[a-z])(?=[A-Z])", " ", name)


def normalize_stem(text: str) -> str:
    n = (text or "").lower().translate(_PUNCT)
    n = re.sub(r"[^a-z0-9'\s]+", " ", n)
    n = re.sub(r"\s+", " ", n).strip()
    return n


def audio_candidates(record: dict) -> list[str]:
    title = (record.get("book_title") or "").strip()
    folder = (record.get("img_folder") or "").strip()
    pdf = record.get("pdf_path") or ""
    pdf_stem = Path(pdf).stem if pdf else ""
    raw: list[str] = []
    for item in (title, folder, spaced_folder(folder) if folder else "", pdf_stem):
        if not item:
            continue
        raw.append(item)
        html = html_apostrophe(item)
        if html != item:
            raw.append(html)
    seen: set[str] = set()
    out: list[str] = []
    for name in raw:
        if name not in seen:
            seen.add(name)
            out.append(name)
    return out


def find_mp3(stage_dir: Path, record: dict) -> Path | None:
    if not stage_dir.is_dir():
        return None
    search_dirs = [stage_dir]
    extra = stage_dir / "音频"
    if extra.is_dir():
        search_dirs.append(extra)
    names = audio_candidates(record)
    for d in search_dirs:
        for name in names:
            p = d / f"{name}.mp3"
            if p.is_file():
                return p
    targets = {normalize_stem(n): n for n in names if n}
    for d in search_dirs:
        for mp3 in sorted(d.glob("*.mp3")):
            if normalize_stem(mp3.stem) in targets:
                return mp3
    return None


def count_images(folder: Path) -> tuple[int, int]:
    if not folder.is_dir():
        return 0, 0
    n = size = 0
    for p in folder.iterdir():
        if p.is_file() and p.suffix.lower() in {".png", ".jpg", ".jpeg", ".webp"}:
            n += 1
            try:
                size += p.stat().st_size
            except OSError:
                pass
    return n, size


def rel_posix(path: Path) -> str:
    return str(path).replace("\\", "/")


def write_csv(path: Path, rows: list[dict], fieldnames: list[str]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8-sig", newline="") as fh:
        writer = csv.DictWriter(fh, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(rows)


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--index", type=Path, default=DEFAULT_INDEX)
    parser.add_argument("--oxford", type=Path, default=DEFAULT_OXFORD)
    parser.add_argument("--dest-root", type=Path, default=DEFAULT_DEST)
    parser.add_argument("--out-dir", type=Path, default=OUT_DIR)
    args = parser.parse_args()

    if not args.index.is_file():
        print(f"missing book-index: {args.index}", file=sys.stderr)
        return 1

    index = json.loads(args.index.read_text(encoding="utf-8"))
    dest = args.dest_root
    oxford = args.oxford
    images_root = oxford / "images"

    book_fields = [
        "book_id",
        "stage",
        "img_folder",
        "fs_slug",
        "book_title",
        "kind",
        "source_path",
        "dest_path",
        "public_url",
        "rewrite_from",
        "page_count_disk",
        "bytes_disk",
        "same_volume",
        "method",
        "notes",
    ]
    rewrite_fields = [
        "kind",
        "from_uri",
        "to_uri",
        "book_id",
        "reason",
    ]

    book_rows: list[dict] = []
    rewrites: list[dict] = []
    missing_images = 0
    missing_audio = 0

    for stage, books in index.items():
        if not isinstance(books, list):
            continue
        for rec in books:
            folder = rec.get("img_folder") or ""
            slug = fs_slug(folder)
            bid = book_id(stage, folder)
            src_img = images_root / stage / folder
            pages, nbytes = count_images(src_img)
            if pages == 0:
                missing_images += 1
            dest_img = dest / "estudy" / "images" / "books" / stage / slug
            public_img = f"/estudy/images/{stage}/{folder}/"
            note = []
            if needs_image_rewrite(folder):
                public_canon = f"/estudy/images/{stage}/{slug}/"
                rewrites.append(
                    {
                        "kind": "image_prefix",
                        "from_uri": public_img,
                        "to_uri": public_canon,
                        "book_id": bid,
                        "reason": "img_folder 含撇号/弯引号/标点，物理目录改为 fs_slug",
                    }
                )
                note.append("image_rewrite")
            same_vol = src_img.exists() and src_img.drive.lower() == dest.drive.lower()
            book_rows.append(
                {
                    "book_id": bid,
                    "stage": stage,
                    "img_folder": folder,
                    "fs_slug": slug,
                    "book_title": rec.get("book_title") or "",
                    "kind": "book_images",
                    "source_path": rel_posix(src_img),
                    "dest_path": rel_posix(dest_img),
                    "public_url": public_img if not needs_image_rewrite(folder) else f"/estudy/images/{stage}/{slug}/",
                    "rewrite_from": public_img if needs_image_rewrite(folder) else "",
                    "page_count_disk": pages,
                    "bytes_disk": nbytes,
                    "same_volume": "yes" if same_vol else "no",
                    "method": "hardlink" if same_vol else "copy",
                    "notes": ";".join(note),
                }
            )

            mp3 = find_mp3(oxford / stage, rec)
            dest_audio_dir = dest / "estudy" / "audio" / "books" / stage / slug
            dest_audio = dest_audio_dir / "book.mp3"
            if mp3 is None:
                missing_audio += 1
                src_audio = ""
                old_uri = f"/estudy/audio/books/{stage}/{rec.get('book_title') or folder}.mp3"
                method = "missing"
                same_a = "no"
            else:
                src_audio = rel_posix(mp3)
                old_uri = f"/estudy/audio/books/{stage}/{mp3.name}"
                same_a = "yes" if mp3.drive.lower() == dest.drive.lower() else "no"
                method = "hardlink" if same_a == "yes" else "copy"
                canon_uri = f"/estudy/audio/books/{stage}/{slug}/book.mp3"
                if old_uri != canon_uri:
                    rewrites.append(
                        {
                            "kind": "book_audio",
                            "from_uri": old_uri,
                            "to_uri": canon_uri,
                            "book_id": bid,
                            "reason": "整本 mp3 收入 per-book 目录，旧文件名（空格/HTML实体）保留重写",
                        }
                    )
            book_rows.append(
                {
                    "book_id": bid,
                    "stage": stage,
                    "img_folder": folder,
                    "fs_slug": slug,
                    "book_title": rec.get("book_title") or "",
                    "kind": "book_audio",
                    "source_path": src_audio,
                    "dest_path": rel_posix(dest_audio),
                    "public_url": f"/estudy/audio/books/{stage}/{slug}/book.mp3",
                    "rewrite_from": old_uri if mp3 is not None else "",
                    "page_count_disk": 1 if mp3 else 0,
                    "bytes_disk": mp3.stat().st_size if mp3 else 0,
                    "same_volume": same_a,
                    "method": method,
                    "notes": "audio_missing" if mp3 is None else "",
                }
            )

    write_csv(args.out_dir / "books.csv", book_rows, book_fields)
    write_csv(args.out_dir / "url-rewrites.csv", rewrites, rewrite_fields)

    n_books = sum(1 for r in book_rows if r["kind"] == "book_images")
    print(f"books={n_books} image_rows={n_books} audio_missing={missing_audio} images_missing={missing_images}")
    print(f"rewrites={len(rewrites)}")
    print(f"wrote {args.out_dir / 'books.csv'}")
    print(f"wrote {args.out_dir / 'url-rewrites.csv'}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())
