public/lib.typ

// 定义双行夹批/批注宏
// 将批注文字分为左右两列，组合成标准宽度(1em)的格子，适当缩减高度以减小垂直间距
#let jiapi(body) = {
  let text-str = if type(body) == str { body } else { body.text }
  let chars = ("（",) + text-str.clusters() + ("）",)
  let n = chars.len()
  let half = int(calc.ceil(n / 2))
  
  let boxes = ()
  let i = 0
  while i < half {
    let c1 = chars.at(i) // 右列字符（先读）
    let c2 = if i + half < n { chars.at(i + half) } else { none } // 左列字符（后读）
    
    // 将高度从 1em 缩减到 0.6em，使批注在垂直方向更紧凑，符合传统夹批的视觉效果
    boxes.push(
      box(width: 1em, height: 0.6em)[
        #set text(size: 0.5em, tracking: 0pt, fill: red)
        #align(center + horizon)[
          #if c2 == none {
            // 如果左列没有字了，只渲染右列（在 rtl 环境下，放在第一个 grid 单元格即可，它会被排在右边）
            grid(
              columns: (50%, 50%),
              align: center + horizon,
              c1, []
            )
          } else {
            // 在 rtl 环境下，grid 先渲染的在右，后渲染的在左
            // 先读右列(c1)，再读左列(c2)，所以传参顺序是 c1, c2
            grid(
              columns: (50%, 50%),
              align: center + horizon,
              c1, c2
            )
          }
        ]
      ]
    )
    i += 1
  }
  
  boxes.join()
}

#let extract-text(node) = {
  if node.has("text") {
    node.text
  } else if node.has("children") {
    let result = ""
    for child in node.children {
      result += extract-text(child)
    }
    result
  } else if node.has("body") {
    let result = extract-text(node.body)
    if node.func() == par {
      result + "\n"
    } else {
      result
    }
  } else {
    ""
  }
}

#let push-tokens(target, source) = {
  for item in source {
    target.push(item)
  }
}

#let tokenize-text(text, link-dest: none) = {
  let tokens = ()
  for ch in text.clusters() {
    if ch == "\r" {
      // 忽略 CR，统一按 LF 处理
    } else if ch == "\n" {
      tokens.push(("newline", none))
    } else if ch == " " or ch == "　" {
      tokens.push(("space", ch))
    } else if ch == "\t" {
      tokens.push(("tab", none))
    } else {
      let glyph = if link-dest != none {
        ("coord", ch, link-dest)
      } else {
        ("content", ch)
      }
      tokens.push(glyph)
    }
  }
  tokens
}

#let tokenize-content(node, link-dest: none) = {
  let tokens = ()

  if node == none {
    tokens
  } else if type(node) == str {
    tokenize-text(node, link-dest: link-dest)
  } else {
    let fields = node.fields()
    let text = fields.at("text", default: none)
    let children = fields.at("children", default: none)
    let body = fields.at("body", default: none)
    let dest = fields.at("dest", default: none)

    if text != none {
      tokenize-text(text, link-dest: link-dest)
    } else if children != none {
      for child in children {
        push-tokens(tokens, tokenize-content(child, link-dest: link-dest))
      }
      if tokens.len() == 0 {
        tokenize-text(extract-text(node), link-dest: link-dest)
      } else {
        tokens
      }
    } else if node.func() == link and body != none and dest != none {
      push-tokens(tokens, tokenize-content(body, link-dest: dest))
      if tokens.len() == 0 {
        tokenize-text(extract-text(node), link-dest: dest)
      } else {
        tokens
      }
    } else if body != none {
      push-tokens(tokens, tokenize-content(body, link-dest: link-dest))
      if node.func() == par {
        tokens.push(("newline", none))
      }
      if tokens.len() == 0 {
        tokenize-text(extract-text(node), link-dest: link-dest)
      } else {
        tokens
      }
    } else {
      let fallback = extract-text(node)
      if fallback == "" {
        tokens
      } else {
        tokenize-text(fallback, link-dest: link-dest)
      }
    }
  }
}

#let calligraphy-paper(
  cols: 12, // 田字格列数
  rows: 18, // 田字格行数
  color: red, // 田字格线条颜色
  size: 4em, // 田字格大小（字体尺寸）
  blank-row: 2, // 底部留空的行数
  blank-col: 2, // 右侧留空的列数
  type: "Normal", // 田字格类型：Normal（默认）、AllH（全留空行）、AllV（全留空列）、Full（无留白）
  show-tian-zi: true, // 是否显示田字格线条
  spacing: 1.2em, // 田字格内部线条的间距
) = {
  // 根据类型调整空行和空列设置
  if type == "AllH" {
    blank-col = 0 // 全部行留空，列不留空
    blank-row = rows
  } else if type == "AllV" {
    blank-col = cols // 全部列留空，行不留空
    blank-row = 0
  } else if type == "Full" {
    blank-col = 0 // 无留白
    blank-row = 0
  }

  // 定义田字格的绘制内容（斜线和中线）
  let tianzi = [
    #line(angle: 45deg, length: (calc.sqrt(2)) * 100%, stroke: (paint: color, dash: "dashed"))  // 右上至左下的斜线
    #v(-spacing)
    #line(angle: -45deg, length: (calc.sqrt(2)) * 100%, stroke: (paint: color, dash: "dashed")) // 左上至右下的斜线
    #v(-spacing - 0.5 * size)
    #line(length: 100%, stroke: (paint: color, dash: "dashed")) // 水平中心线
    #v(-spacing - 0.5 * size)
    #line(angle: 90deg, length: 100%, stroke: (paint: color, dash: "dashed")) // 垂直中心线
  ]

  // 设置田字格网格布局
  set grid(
    columns: (size,) * cols, // 定义网格列数及尺寸
    rows: (size,) * rows, // 定义网格行数及尺寸
    stroke: color, // 网格线颜色
  )

  // 渲染田字格
  rotate(180deg)[
    #figure(
      grid(
        grid.hline(stroke: 3pt, y: 0), // 顶部边界线
        grid.vline(stroke: 3pt, x: 0), // 左侧边界线
        grid.vline(stroke: 3pt, x: cols), // 右侧边界线
        grid.hline(stroke: 3pt, y: rows), // 底部边界线

        // 渲染右侧空列
        ..(grid.cell(rowspan: rows)[],) * blank-col,

        // 渲染底部空行
        ..(grid.cell(colspan: if cols > blank-col { cols - blank-col } else { 1 })[],) * blank-row,

        // 渲染剩余田字格区域
        ..(
          grid.cell()[ #if show-tian-zi { tianzi } ],
        )
          * (cols - blank-col)
          * (rows - blank-row)
      ),
    )
  ]
}

#let calligraphy-work(
  font: "FZYingBiKaiShu-S15S", // 默认字体（方正硬笔楷书）
  size: 4em, // 字体大小
  cols: 12, // 列数
  rows: 18, // 行数
  color: red, // 田字格颜色
  blank-row: 2, // 底部空行数
  blank-col: 2, // 右侧空列数
  type: "Normal", // 纸张类型
  show-tian-zi: true, // 是否显示田字格
  miao: false, // 是否启用描红（灰色字样）
  paper: "a4", // 纸张大小
  width: auto, // 自定义纸张宽度
  height: auto, // 自定义纸张高度
  first-line-indent: true,
  spacing-rate: 29%,
  x-rate: 16%,
  y-rate: 26%,
  col-gutter: 0pt, // 列间距（用于AllV模式）
  // Vertical punctuation positioning (for AllV mode)
  punc-dx: 0.01em,  // 标点符号水平偏移（向右推，避免重叠）
  punc-dy: -0.001em, // 标点符号垂直偏移（向上推）
  open-bracket-dx: 0pt, // 开括号水平偏移
  open-bracket-dy: 0.2em, // 开括号垂直偏移
  close-bracket-dx: 0pt, // 闭括号水平偏移
  close-bracket-dy: -0.3em, // 闭括号垂直偏移
  sutegana-dx: 0.15em, // 小假名水平偏移
  sutegana-dy: -0.1em, // 小假名垂直偏移
  sutegana-scale: 0.8, // 小假名缩放比例
  body, // 书写内容
) = {
  let paper-sizes = (
    "a3": (297mm, 420mm),
    "a4": (210mm, 297mm),
    "a5": (148mm, 210mm),
    "iso-b5": (176mm, 250mm),
    "us-letter": (8.5in, 11in),
    "us-legal": (8.5in, 14in),
  )

  let (default-w, default-h) = if paper in paper-sizes {
    paper-sizes.at(paper)
  } else {
    (210mm, 297mm)
  }

  let pw = if width != auto { width } else { default-w }
  let ph = if height != auto { height } else { default-h }

  // 根据类型调整空行和空列设置，以便正确计算页边距
  if type == "AllH" {
    blank-col = 0
    blank-row = rows
  } else if type == "AllV" {
    blank-col = cols
    blank-row = 0
  } else if type == "Full" {
    blank-col = 0
    blank-row = 0
  }

  let spacing = 1em * spacing-rate // 文字行间距
  let x = (pw - size * cols) / 2 + 1em * x-rate // 水平边距计算
  let y = (ph - size * rows) / 2 + 1em * y-rate // 垂直边距计算
  let tracking = 1em * 15% // 字符间距调整

  // 计算用于页边距避让的空白列数
  // 如果是 AllV 模式，虽然 blank-col 为 cols，但不应该避让，否则无法显示内容
  let margin-blank-col = if type == "AllV" { 0 } else { blank-col }

  // 计算用于页边距避让的空白行数
  // 如果是 AllH 模式，虽然 blank-row 为 rows，但不应该避让，否则无法显示内容
  let margin-blank-row = if type == "AllH" { 0 } else { blank-row }

  let page-settings = (
    paper: paper,
    margin: (left: x, top: y, right: x + size * margin-blank-col, bottom: y + size * margin-blank-row), // 页边距设置
    background: calligraphy-paper(
      spacing: spacing,
      cols: cols,
      rows: rows,
      color: color,
      blank-row: blank-row,
      blank-col: blank-col,
      type: type,
      show-tian-zi: show-tian-zi,
      size: size,
    ),
    footer: context [
      #set text(size: 14pt, fill: black, weight: "bold")
      #set align(center)
      #move(dy: 10pt)[#counter(page).display("- 1 -")]
    ],
  )

  if width != auto { page-settings.insert("width", width) }
  if height != auto { page-settings.insert("height", height) }

  set page(..page-settings)

  let par-settings = (
    leading: spacing,
    spacing: spacing,
    first-line-indent: if first-line-indent {
      (amount: 2.3em, all: true,)
    } else {
      (amount: 0pt, all: false)
    },
  )
  set par(..par-settings) // 行距设置

  // Vertical punctuation helpers for AllV mode
  // 标点符号（逗号、顿号、句号等）- 右上角
  let vp(p) = box(
    width: 1em,
    height: 0.8em,
    move(dx: punc-dx, dy: punc-dy)[#p]
  )
  
  // 开括号（﹁ ︵ 等）- 底部居中
  let vpo(p) = box(
    width: 1em,
    height: 0.8em,
    move(dx: open-bracket-dx, dy: open-bracket-dy)[#p]
  )
  
  // 闭括号（﹂ ︶ 等）- 顶部居中
  let vpc(p) = box(
    width: 1em,
    height: 0.8em,
    move(dx: close-bracket-dx, dy: close-bracket-dy)[#p]
  )

  // Small kana helper - positioned slightly right for vertical text
  let vk(p) = box(
    width: 1em,
    height: 1em,
    move(dx: sutegana-dx, dy: sutegana-dy)[#text(size: sutegana-scale * 1em)[#p]]
  )

  let text-settings = (
    size: size * 87%, // 字体大小调整
    font: font, // 字体
    lang: "cn", // 语言设置
    tracking: tracking, // 字符间距
    fill: if miao { gray } else { black }, // 是否描红
  )

  let h-cell(content) = box(
    width: size,
    height: size,
    inset: 0pt,
    [
      #set text(..text-settings)
      #align(center + horizon)[#content]
    ]
  )

  let empty-h-cell = box(width: size, height: size)

  if type == "AllH" {
    // 真正的横排字帖模式：逐字拆分后按固定列数排入格子，确保每个字都待在红框内
    let tokens = tokenize-content(body)
    let cells = ()
    let col-index = 0
    let seen-content = false
    let at-line-start = true

    let push-newline = {
      if seen-content {
        let remainder = col-index
        while remainder >= cols {
          remainder -= cols
        }
        let pad = if remainder == 0 {
          if at-line-start { cols } else { 0 }
        } else {
          cols - remainder
        }

        let i = 0
        while i < pad {
          cells.push(empty-h-cell)
          col-index += 1
          i += 1
        }
      }
      at-line-start = true
    }

    if tokens.len() > 0 {
      for token in tokens {
        let kind = token.at(0)
        if kind == "newline" {
          push-newline()
        } else if (kind == "space" or kind == "tab") and at-line-start {
          // 忽略源码缩进，避免内容块内部的排版空格误占格子
        } else if kind == "space" or kind == "tab" {
          let span = if kind == "tab" { 2 } else { 1 }
          let i = 0
          while i < span {
            cells.push(empty-h-cell)
            col-index += 1
            i += 1
          }
          seen-content = true
          at-line-start = false
        } else if kind == "coord" {
          cells.push(link(token.at(2))[#h-cell(token.at(1))])
          col-index += 1
          seen-content = true
          at-line-start = false
        } else {
          cells.push(h-cell(token.at(1)))
          col-index += 1
          seen-content = true
          at-line-start = false
        }
      }
    } else {
      let chars = extract-text(body).clusters()
      for ch in chars {
        if ch == "\r" {
        // 忽略 CR，统一按 LF 处理
        } else if ch == "\n" {
          push-newline()
        } else if (ch == " " or ch == "\t") and at-line-start {
        // 忽略源码缩进，避免内容块内部的排版空格误占格子
        } else if ch == " " or ch == "　" or ch == "\t" {
          let span = if ch == "\t" { 2 } else { 1 }
          let i = 0
          while i < span {
            cells.push(empty-h-cell)
            col-index += 1
            i += 1
          }
          seen-content = true
          at-line-start = false
        } else {
          cells.push(h-cell(ch))
          col-index += 1
          seen-content = true
          at-line-start = false
        }
      }
    }

    if cells.len() == 0 {
      []
    } else {
      grid(
        columns: (size,) * cols,
        stroke: none,
        ..cells,
      )
    }
  } else if type == "AllV" {
    // 伪竖排效果：使用分栏布局，每栏宽度为一个字宽
    // Apply show rules for automatic vertical punctuation
    // 使用 Unicode 竖排兼容标点符号 (Vertical Forms) 替换普通全角标点，获得原生竖排体验
    show "，": vp[︐]
    show "、": vp[︑]
    show "。": vp[︒]
    show "．": vp[︒]
    show "：": vp[︓]
    show "；": vp[︔]
    show "！": box(width: 1em, height: 1em, align(center + horizon)[︕])
    show "？": box(width: 1em, height: 1em, align(center + horizon)[︖])
    show "!": box(width: 1em, height: 1em, align(center + horizon)[︕])
    show "?": box(width: 1em, height: 1em, align(center + horizon)[︖])
    show "「": vpo[﹁]
    show "」": vpc[﹂]
    show "『": vpo[﹃]
    show "』": vpc[﹄]
    show "（": vpo[︵]
    show "）": vpc[︶]
    show "【": vpo[︻]
    show "】": vpc[︼]
    show "〈": vpo[︿]
    show "〉": vpc[﹀]
    show "《": vpo[︽]
    show "》": vpc[︾]
    
    // 处理普通空格，将其转换为一个全角空格宽度的占位符，防止在竖排分栏中被压或忽略
    // show " ": box(width: 1em, height: 1em)
    // 忽略普通空格（源码中的换行符会被解析为普通空格）。
    // 如果需要占位空格，请使用全角空格（　）或 #h(1em)
    show " ": none
    show "　": box(width: 1em, height: 1em)

    // 去除链接的默认颜色和下划线，不影响视觉效果
    show link: set text(fill: black)
    
    // Outline 目录样式调整，防止长标题导致换列错位
    show outline.entry: it => {
      // 在伪竖排下，由于使用了单字符宽度的 columns 布局，直接渲染长字符串
      // 会导致某些字符由于网格计算或链接包裹的原因向右溢出到前一列
      // 为了强制竖排并换列，我们将标题拆分成单字，并让每个字强制占据一个标准字宽的块
      let chars = it.element.body.text.clusters()
      
      link(it.element.location())[
        #for c in chars {
          if c == " " {
            // 将空格处理为 1em 的透明块
            box(width: 1em, height: 1em)
          } else {
            // 强制将每个字符包裹在一个 1em 宽度的 box 中，阻止它向右溢出
            // 添加 height: 1em 确保每一个字都在各自独立的格子里，保持行距均匀
            box(width: 1em, height: 1em, move(dx: 0.15em, dy: 0.15em)[#c])
          }
        }
        // 在标题和页码之间加一点间距
        #box(width: 1em, height: 0.5em)
        // 页码单独占据一个字块
        #box(width: 1em, height: 1em, move(dx: 0.15em, dy: 0.15em)[#text(size: 0.7em)[#it.page()]])
      ]
    }
    
    // Small hiragana (sutegana) - positioned upper-right
    show "っ": vk[っ]
    show "ゃ": vk[ゃ]
    show "ゅ": vk[ゅ]
    show "ょ": vk[ょ]
    show "ぁ": vk[ぁ]
    show "ぃ": vk[ぃ]
    show "ぅ": vk[ぅ]
    show "ぇ": vk[ぇ]
    show "ぉ": vk[ぉ]
    
    // Small katakana - positioned upper-right
    show "ッ": vk[ッ]
    show "ャ": vk[ャ]
    show "ュ": vk[ュ]
    show "ョ": vk[ョ]
    show "ァ": vk[ァ]
    show "ィ": vk[ィ]
    show "ゥ": vk[ゥ]
    show "ェ": vk[ェ]
    show "ォ": vk[ォ]
    
    let content = text(..text-settings)[
      #body  // 渲染书写内容
    ]
    
    columns(cols, gutter: col-gutter, content)
  } else {
    let content = text(..text-settings)[
      #body  // 渲染书写内容
    ]
    content
  }
}

#let c(char, poly) = link("coord:" + poly)[#char]