common.typ

#import "@preview/cetz:0.5.2": canvas, draw
#import "@preview/fletcher:0.5.8" as fletcher: diagram, node, edge
#let diagram = diagram.with(label-size: 0.85em, label-sep: 0.15em)
#let edgeL = edge.with(label-side: left)
#let edgeR = edge.with(label-side: right)
#let edgeM = edge.with(label-side: center)

#let hyperlink(dest, body) = link(dest, underline(text(fill: color.oklch(45%, 55%, 250deg), body), offset: 0.2em))
#let author-note(body) = [
  #set text(fill: luma(60%))
  #body
]
#let author-notes(body) = block(fill: luma(90%), radius: 0.5em, outset: 0.5em)[
  #body
]

// Translation (used for indexing)
#let translation-table = state("translations", ())
#let add-entry(zh, en, key) = translation-table.update(it => {
  let actual = key
  if actual == none {
    actual = en.at("text", default: "")
  }
  it.push((zh, en, actual))
  it
})
#let translate(zh, en, key:none) = [#zh #text(fill: luma(40%))[(#en)]#add-entry(zh,en,key)]
#let define(zh, en, key:none) = [*#zh* #text(fill: luma(40%))[(#en)]#add-entry(zh,en,key)]

// Defintions
#import "@preview/ctheorems:1.1.3": *
#let thmstyle = thmplain.with(
  separator: [*.* ],
  titlefmt: strong,
  namefmt: x => [(#x)],
  bodyfmt: content => content + parbreak(),
  inset: (left: 0em, right: 0em),
  base_level: 2
)

#let theorem = thmstyle("theorem", "定理")
#let lemma = thmstyle("theorem", "引理")
#let definition = thmstyle("theorem", "定义")
#let proof = thmproof(
  "proof", "证明",
  separator: h(0em),
  titlefmt: box.with(stroke: 0.5pt, outset: (top: 0.25em, bottom: 0.25em, left: 0.1em, right: 0.1em)),
  inset: (left: 0em, right: 0em),
)
// In appendices, we need to fix the numbering
#let theorem-appendix = theorem.with(numbering: "A.1")
#let lemma-appendix = lemma.with(numbering: "A.1")
#let definition-appendix = definition.with(numbering: "A.1")

// Figure
#let numbered-figure = figure.with(kind: "numbered-figure", supplement: "图表", numbering: "1", gap: 1em)

// Equations
#let eq(content, top: 0pt, bottom: 0pt, ..style) = [\
  #box(align(center, content), width: 1fr, inset: (top: top, bottom: bottom))\
] // TODO manually tune some vertical spacing

// Inference rules
#let rule(concl, ..prem) = if type(prem.at(0, default: none)) == array {
    math.frac(box(
      inset: (bottom: 0.25em),
      prem.pos()
      .map(it => math.equation(it.intersperse(math.quad).join()))
      .intersperse("\n").join()
    ),
      concl.intersperse(math.quad).join())
  } else {
    math.frac(prem.pos().intersperse(math.quad).join(),concl)
  }
#let partir(..rules) = for rule in rules.pos() {
  box(math.equation(rule, block: true), inset: (left: 1em, right: 1em))
}

// Logical framework
#let LFcolor = color.oklch(70%, 80%, 140deg).transparentize(85%)
#let LF = box.with(
  fill: LFcolor,
  outset: (left: 0.1em, right: 0.1em, top: 0.3em, bottom: 0.35em), radius: 0.2em)
// TODO replace with  highlight.with(fill: color.oklch(70%, 80%, 140deg).transparentize(80%), ...)  once it is fixed
#let eqLF(content) = eq(box(
  fill: LFcolor,
  outset: (left: 0.3em, right: 0.3em, top: 0.3em, bottom: 0.35em), radius: 0.2em, content))
#let lfTp = math.italic("Tp")
#let lfEl = math.italic("El")

// Other type theoretic stuff
#let istype = math.class("relation", math.sans("type"))
#let isnf = math.class("relation",text(fill: color.oklch(50%, 80%, 200deg), math.sans("nf")))
#let isne = math.class("relation",text(fill: color.oklch(50%, 80%, 80deg), math.sans("ne")))
#let isvar = math.class("relation",text(fill: color.oklch(50%, 0%, 0deg), math.sans("var")))
#let typeof = math.op("typeof")
#let interpret(x) = math.lr(math.class("opening",sym.bracket.stroked) + x + math.class("closing",sym.bracket.stroked.r))
#let bind = math.class("punctuation", ".")
#let Empty = math.bb("0")
#let Unit = math.bb("1")
#let Bool = math.bb("2")
#let ite(b,t,f) = $"if" #b "then" #t "else" #f$
#let refl = math.op(text("refl", font: "New Computer Modern"))
#let transp = math.op(text("transport", font: "New Computer Modern"))
#let contr = math.op(text("contr", font: "New Computer Modern"))
#let Set = math.sans("Set")
#let Psh = math.sans("Psh")
#let yo = math.class("unary", box("よ", inset: (left: -0.1em, right: -0.1em)))
#let cod = math.op("cod")
#let dom = math.op("dom")

#let xarrow(arrow: sym.arrow, ..args, sup: none, sub: none) = {
  if args.pos().len() >= 1 {
    sup = args.pos().at(0)
  }
  if args.pos().len() >= 2 {
    sub = args.pos().at(1)
  }
  context {
    let lsup = measure($script(sup)$)
    let lsub = measure($script(sub)$)
    math.attach(math.stretch(arrow, size: calc.max(lsup.width, lsub.width) + 0.75em), t: box($script(sup)$, inset: (bottom: -0.3em)), b: box($script(sub)$, inset: (top: -1.1em), baseline: 100%))
  }
}
#let corner = symbol(
  "⌜",
  ("ul", "⌜"),
  ("ur", "⌝"),
  ("ll", "⌞"),
  ("lr", "⌟"),
)
#let corner-dict = (
  "dr": corner.lr,
  "dl": corner.ll,
  "ul": corner.ul,
  "ur": corner.ur
)
#let pullback(n) = edgeM("dr", " ", corner-dict.at(n), label-pos: 0%, label-size: 1em)