#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
gen_font.py — MeowOS 预渲染字库生成器（主机侧）· v2：像素进 PNG、索引进 idx。

产出（单份存储，设备与主机共用同一套字节）：
    <out>/font.png   灰度 PNG（bit depth 4|8），含全部字号的面，每面一个子矩形
    <out>/font.idx   二进制索引：头部 + 每面元数据 + 每字符 16B 记录

设计要点：
  * 像素只存一次（font.png）；idx 只做索引。设备端用 zlib inflate + 自写 PNG 反滤波解码，
    无需 libpng（目标根文件系统无 libpng，仅有 zlib）。
  * 位深默认 4（16 级 alpha，仍抗锯齿）以把多张高密度汉字面压到 ≤2MB 预算内；8-bit 会超。
    --bitdepth 8 可出 8-bit（建议单字号）。
  * 绘制模型：drawtext(fb,x,y,str,color,size)，(x,y)=行首「升线顶」锚点；baseline=y+ascent；
    每字形 blit 于 (x+pen+dx, y+dy)，pen 累加 advance。

idx 二进制布局（little-endian, version=2）：
    Header(16B):
        +0  u8[4] magic='MFNI'
        +4  u16  version=2
        +6  u8   bit_depth (4|8)
        +7  u8   face_count
        +8  u32  png_w
        +12 u32  png_h
    FaceHeader ×face_count (20B each):
        +0  u16  px_size
        +2  u16  plane_x
        +4  u16  plane_y     (PNG 像素内面左上角)
        +6  u16  plane_w
        +8  u16  plane_h
        +10 i16  ascent
        +12 i16  descent     (负值)
        +14 u16  glyph_count
        +16 u32  glyph_offset (文件内本面 glyph 表偏移)
    Glyph 表（每面按 codepoint 升序，16B each）:
        +0  u32  codepoint
        +4  u16  x           (PNG 像素左上角，已含 offset)
        +6  u16  y
        +8  u16  w
        +10 u16  h
        +12 u16  advance
        +14 i8   dx
        +15 u8   dy
"""
import argparse
import hashlib
import json
import os
import struct
import unicodedata
import zlib

from PIL import Image, ImageDraw, ImageFont

MAGIC = b"MFNI"
VER = 2


# --------------------------------------------------------------------------
# PNG 编码（灰度, bit depth 4|8, 全部扫描行 filter=0；规范解码器可读）
# --------------------------------------------------------------------------
def _png_chunk(ctype, data):
    c = ctype + data
    return struct.pack(">I", len(data)) + c + struct.pack(">I", zlib.crc32(c) & 0xFFFFFFFF)


def gray_png_encode(width, height, depth, packed):
    rowbytes = (width * depth + 7) // 8
    ihdr = struct.pack(">IIBBBBB", width, height, depth, 0, 0, 0, 0)  # gray, compression0 filter0 interlace0
    raw = bytearray()
    for y in range(height):
        raw.append(0)  # filter type 0 (None)
        raw += packed[y * rowbytes:(y + 1) * rowbytes]
    idat = zlib.compress(bytes(raw), 9)
    out = b"\x89PNG\r\n\x1a\n"
    out += _png_chunk(b"IHDR", ihdr)
    out += _png_chunk(b"IDAT", idat)
    out += _png_chunk(b"IEND", b"")
    return out


def pack_plane_depth(plane_l8, width, height, depth):
    """把 L8 行主序 plane 转为指定 bit depth 的打包字节。"""
    if depth == 8:
        return bytes(plane_l8)
    assert depth == 4
    rowbytes = (width + 1) // 2
    out = bytearray()
    for y in range(height):
        base = y * width
        row = bytearray(rowbytes)
        for x in range(0, width, 2):
            a = plane_l8[base + x]
            b = plane_l8[base + x + 1] if x + 1 < width else 0
            row[x // 2] = ((a >> 4) << 4) | (b >> 4)
        out += row
    return bytes(out)


# --------------------------------------------------------------------------
# 字符集（字体档位：common / gbk / full）
#   口径见 docs/MEOWOS_SPEC_REF.md §5.2「字体档位/大字库」与 §5.7.8：
#     common ≈ 4k 码位（ASCII + GB2312 常用 + 标点 + --extra） = 现状；
#     gbk   ≈ 20k+（再并入 CJK 统一表意 U+4E00-9FFF + CJK 符号/全角，含常用简繁/生僻）；
#     full  ≈ 全 Unicode 可渲染区间（gbk + CJK 扩展 A/B-F + 拉丁/希腊/西里尔 + 通用标点，可选）。
#   每档在产物 font.json 写入 charset + glyph_count（见 write_font_json）。
# --------------------------------------------------------------------------
CHARSET_TIERS = ("common", "gbk", "full")
CHARSET_ALIAS = {"0": "common", "common": "common", "1": "gbk", "gbk": "gbk",
                 "2": "full", "full": "full"}


def build_charset(tier="common", extra=""):
    if tier not in CHARSET_TIERS:
        tier = "common"
    cps = []
    def add(cp):
        if 0 <= cp <= 0x10FFFF and cp not in cps:
            cps.append(cp)
    # ASCII 可打印字符
    for c in range(0x20, 0x7F):
        add(c)
    # GB2312 一/二级常用简体（B0-D7 + D8 常用二级首段）
    for hi in range(0xB0, 0xD8):
        for lo in range(0xA1, 0xFF):
            try:
                add(ord(bytes([hi, lo]).decode("gb2312")))
            except UnicodeDecodeError:
                pass
    # GB2312 符号/全角（A1-A4）
    for hi in range(0xA1, 0xA5):
        for lo in range(0xA1, 0xFF):
            try:
                add(ord(bytes([hi, lo]).decode("gb2312")))
            except UnicodeDecodeError:
                pass
    if tier in ("gbk", "full"):
        # CJK 统一表意（含常用简繁/生僻）：U+4E00-9FFF ≈ 2万+
        for cp in range(0x4E00, 0xA000):
            add(cp)
        # CJK 符号与标点 + 全角形式（补齐 common 未含的）
        for cp in range(0x3000, 0x3040):
            add(cp)
        for cp in range(0xFF00, 0xFFF0):
            add(cp)
    if tier == "full":
        # 拉丁补充 / 希腊 / 西里尔 等常用非 CJK（Latin-1 起已覆盖 AI 常见重音）
        for cp in range(0xA0, 0x0530):
            add(cp)
        # CJK 扩展 A + 兼容表意
        for cp in range(0x3400, 0x4DC0):
            add(cp)
        for cp in range(0xF900, 0xFB00):
            add(cp)
        # 通用标点 / 货币等（— … “ ” 等已在 gbk；此处补全）
        for cp in range(0x2000, 0x2070):
            add(cp)
        for cp in range(0x20A0, 0x20D0):
            add(cp)
        # CJK 扩展 B-F（补充平面）
        for cp in range(0x20000, 0x2EBF0):
            add(cp)
        for cp in range(0x30000, 0x31350):
            add(cp)
    for ch in extra:
        add(ord(ch))
    return sorted(cps)


def charset_glyph_count(cps):
    """glyph_count = 字符集码位数（信息用，落 font.json）。"""
    return len(cps)


# --------------------------------------------------------------------------
# 逐字形渲染
# --------------------------------------------------------------------------
class Glyph:
    __slots__ = ("cp", "w", "h", "dx", "dy", "adv", "pixels")

    def __init__(self, cp, w, h, dx, dy, adv, pixels):
        self.cp, self.w, self.h, self.dx = cp, w, h, dx
        self.dy, self.adv, self.pixels = dy, adv, pixels


def render_one(font, ch, pad):
    asc, desc = font.getmetrics()
    # Pillow: ascent & descent 均为正; 字体行高 = asc + |desc|（desc 或为负，用 abs 归一）
    line_h = asc + abs(desc)
    Wc = int(font.getlength(ch)) + 2 * pad + 16
    Hc = line_h + 2 * pad
    img = Image.new("L", (Wc, Hc), 0)
    ImageDraw.Draw(img).text((pad, pad), ch, font=font, fill=255)
    bb = img.getbbox()
    if bb is None:
        return Glyph(ord(ch), 0, 0, 0, 0, int(round(font.getlength(ch))), None)
    l, t, r, b = bb
    return Glyph(ord(ch), r - l, b - t, l - pad, t - pad,
                 int(round(font.getlength(ch))), img.crop((l, t, r, b)).tobytes())


# --------------------------------------------------------------------------
# 打包（decreasing-height 书架式；枚举多个最大宽求最小面积）
# --------------------------------------------------------------------------
def pack_best(glyphs, gap=1):
    best = None
    for max_w in (256, 384, 512, 640, 768, 1024, 1280, 1536, 2048, 3072):
        items = sorted(enumerate(glyphs), key=lambda t: -t[1].h)
        placements = {}
        x = y = 0
        shelf_h = 0
        cur_w = 0
        for idx, g in items:
            if g.w == 0 or g.h == 0:
                continue
            if cur_w + g.w > max_w:
                y += shelf_h + gap
                x = 0
                cur_w = 0
                shelf_h = 0
            placements[idx] = (x, y)
            x += g.w + gap
            cur_w += g.w + gap
            if g.h > shelf_h:
                shelf_h = g.h
        if not placements:
            continue
        aw = max(placements[i][0] + g.w for i, g in enumerate(glyphs) if i in placements)
        ah = y + shelf_h
        area = aw * ah
        if best is None or area < best[0]:
            best = (area, placements, aw, ah, max_w)
    if best is None:
        return {}, 0, 0, 0
    return best[1], best[2], best[3], best[4]


# --------------------------------------------------------------------------
# idx 写入
# --------------------------------------------------------------------------
def write_idx(path, bit_depth, faces, glyph_tabs):
    n = len(faces)
    png_w = max(f["plane_x"] + f["plane_w"] for f in faces)
    png_h = max(f["plane_y"] + f["plane_h"] for f in faces)
    header = bytearray(struct.pack("<4sHBBII", MAGIC, VER, bit_depth, n, png_w, png_h))
    assert len(header) == 16

    face_off = 16
    glyph_off = face_off + 20 * n
    body = bytearray()
    for i, f in enumerate(faces):
        body += struct.pack("<HHHHHhhHI", f["px"], f["plane_x"], f["plane_y"],
                            f["plane_w"], f["plane_h"], f["ascent"], f["descent"],
                            len(glyph_tabs[i]), 0)

    cur = glyph_off
    tables = []
    offs = []
    for tab in glyph_tabs:
        offs.append(cur)
        tab_sorted = sorted(tab, key=lambda g: g[0])
        buf = bytearray()
        for cp, x, y, w, h, adv, dx, dy in tab_sorted:
            dy = max(dy, 0)  # 少数全角/符号字形墨迹略高于 la 锚点，得到负 dy；u8 仅能表达非负，钳到 0（整体下移 1-3px，肉眼不可见）
            buf += struct.pack("<IHHHHHbB", cp, x, y, w, h, adv, dx, dy)
        tables.append(buf)
        cur += len(buf)

    for i, off in enumerate(offs):
        struct.pack_into("<I", body, i * 20 + 16, off)
    for buf in tables:
        body += buf

    with open(path, "wb") as fp:
        fp.write(bytes(header))
        fp.write(bytes(body))
    return len(header) + len(body)


# --------------------------------------------------------------------------
# font.json（元数据 + 完整性校验；schema 见 docs/MEOWOS_SPEC_REF.md §5.2）
# --------------------------------------------------------------------------
def write_font_json(out_dir, name, family, weight, tier, glyph_count, sizes, bitdepth,
                    png_path, idx_path, source="", license_="", languages=None, label=""):
    def sha256(path):
        h = hashlib.sha256()
        with open(path, "rb") as f:
            for blk in iter(lambda: f.read(1 << 16), b""):
                h.update(blk)
        return h.hexdigest()
    meta = {
        "family": family or name,       # 同目录名（信息用；扫描端以目录名为 family）
        "name": name,                   # 下拉显示名（缺则回退目录名）
        "weight": weight or "regular",  # 字重 slug（regular|bold|italic|…；默认 regular）
        "glyph_count": glyph_count,     # 信息用
        "charset": tier,                # common|gbk|full（档位；驱动按需加载——现行运行时读此作 tier）
        "tier": tier,                   # 档位（FONT_SYSTEM 新增；同 charset 值，供后续运行时迁移）
        "languages": languages or ["zh_cn", "en_us"],  # 详细区域码（FONT_SYSTEM §2.1）
        "size_list": sizes,             # 原生面字号
        "bit_depth": bitdepth,          # 4|8
        "sha256_png": sha256(png_path),  # font.png 校验（扫描端仅 WARN）
        "sha256_idx": sha256(idx_path),  # font.idx 校验（扫描端仅 WARN）
    }
    if label:    meta["label"] = label      # 可选：显示名（如 `思源黑体 CN·粗体·常用`）
    if source:   meta["source"] = source    # 可选：来源（如 "MiSans Regular (Xiaomi)"）
    if license_: meta["license"] = license_  # 可选：许可（如 "SIL Open Font License 1.1"）
    jpath = os.path.join(out_dir, "font.json")
    with open(jpath, "w", encoding="utf-8") as f:
        json.dump(meta, f, ensure_ascii=False, indent=2)
    return jpath


# --------------------------------------------------------------------------
# 主流程
# --------------------------------------------------------------------------
def main():
    ap = argparse.ArgumentParser(description="MeowOS 预渲染字库生成器 v2")
    ap.add_argument("--font", required=True)
    ap.add_argument("--sizes", default="28,20")
    ap.add_argument("--out", required=True)
    ap.add_argument("--name", default="font",
                    help="输出面基名（font.png/font.idx 基名，缺省 font；font.json name 缺省同此）")
    ap.add_argument("--json-name", default="",
                    help="font.json name 显示名（缺省 = --name；用于 png 基名与显示名解耦）")
    ap.add_argument("--family", default="", help="font.json family（缺省 = --name；信息用）")
    ap.add_argument("--weight", default="regular",
                    help="字重 slug（regular|bold|italic|…，缺省 regular；写进 font.json weight）")
    ap.add_argument("--charset", default="common", choices=CHARSET_TIERS,
                    help="字体档位：common≈4k / gbk≈20k+ / full（可选，默认不推）")
    ap.add_argument("--bitdepth", type=int, default=4, choices=(4, 8))
    ap.add_argument("--extra", default="")
    ap.add_argument("--source", default="", help="可选：font.json source 来源说明")
    ap.add_argument("--license", default="", help="可选：font.json license 许可")
    ap.add_argument("--languages", default="zh_cn,en_us",
                    help="font.json languages 区域码（逗号分隔，FONT_SYSTEM §2.1；默认 zh_cn,en_us）")
    ap.add_argument("--label", default="", help="可选：font.json label 显示名")
    args = ap.parse_args()

    os.makedirs(args.out, exist_ok=True)
    sizes = [int(s) for s in args.sizes.split(",") if s.strip()]
    tier = CHARSET_ALIAS.get(args.charset, "common")
    json_name = args.json_name if args.json_name else args.name
    cps = build_charset(tier, args.extra)
    print(f"字符集: {len(cps)} 码位 (charset={tier})")

    all_planes = []  # (aw, ah, plane_l8 bytes, tab)
    max_w = 0
    for size in sizes:
        print(f"\n=== 字号 {size}px ===")
        font = ImageFont.truetype(args.font, size)
        asc, desc = font.getmetrics()
        print(f"  metrics ascent={asc} descent={desc}")

        glyphs = []
        miss = []
        for cp in cps:
            ch = chr(cp)
            g = render_one(font, ch, pad=8)
            if g.w == 0 and g.h == 0 and cp != 0x20:
                miss.append(ch)
            glyphs.append(g)
        if miss:
            print(f"  [warn] {len(miss)} 码位无字形(保留advance): {''.join(miss[:20])}")

        placements, aw, ah, chosen = pack_best(glyphs)
        print(f"  packing atlas {aw}x{ah} (max_w={chosen}) glyphs={len(glyphs)}")

        plane_l8 = bytearray(aw * ah)
        tab = []
        for i, g in enumerate(glyphs):
            if i in placements:
                px, py = placements[i]
                for row in range(g.h):
                    s = row * g.w
                    d = (py + row) * aw + px
                    plane_l8[d:d + g.w] = g.pixels[s:s + g.w]
                tab.append((g.cp, px, py, g.w, g.h, g.adv, g.dx, g.dy))
            else:
                tab.append((g.cp, 0, 0, 0, 0, g.adv, 0, 0))
        all_planes.append((aw, ah, bytes(plane_l8), tab))
        max_w = max(max_w, aw)

    # ---- 编排到公共画布（纵向堆叠，公共宽 max_w 偶数化） ----
    if max_w % 2:
        max_w += 1
    total_h = sum(p[1] for p in all_planes)
    canvas_l8 = bytearray(max_w * total_h)
    face_meta = []
    fy = 0
    for i, (aw, ah, plane, tab) in enumerate(all_planes):
        for y in range(ah):
            src = y * aw
            dst = (fy + y) * max_w
            canvas_l8[dst:dst + aw] = plane[src:src + aw]
        face_meta.append({"px": sizes[i], "plane_x": 0, "plane_y": fy,
                          "plane_w": aw, "plane_h": ah,
                          "ascent": int(ImageFont.truetype(args.font, sizes[i]).getmetrics()[0]),
                          "descent": int(abs(ImageFont.truetype(args.font, sizes[i]).getmetrics()[1]))})
        fy += ah

    # ---- 打包 + PNG ----
    packed = pack_plane_depth(canvas_l8, max_w, total_h, args.bitdepth)
    png_bytes = gray_png_encode(max_w, total_h, args.bitdepth, packed)
    png_path = os.path.join(args.out, f"{args.name}.png")
    with open(png_path, "wb") as fp:
        fp.write(png_bytes)

    # ---- idx ----
    idx_path = os.path.join(args.out, f"{args.name}.idx")
    idx_size = write_idx(idx_path, args.bitdepth, face_meta, [p[3] for p in all_planes])

    # ---- font.json（写入 weight + charset + glyph_count + sha256，供扫描端标注档位/大小标记） ----
    languages = [l.strip() for l in args.languages.split(",") if l.strip()]
    jpath = write_font_json(args.out, json_name, args.family, args.weight, tier, charset_glyph_count(cps),
                            sizes, args.bitdepth, png_path, idx_path,
                            args.source, args.license, languages, args.label)

    png_size = os.path.getsize(png_path)
    total = png_size + idx_size
    print(f"\nfont.png {png_size} B")
    print(f"font.idx {idx_size} B")
    print(f"font.json {os.path.getsize(jpath)} B (charset={tier}, weight={args.weight or 'regular'}, glyph_count={len(cps)})")
    print(f"合计 {total} B = {total/1024:.1f} KiB = {total/1048576:.2f} MiB (预算 2MiB)")


if __name__ == "__main__":
    main()