#let INDENT = 1.4em
#let indent = h(INDENT)

#let title-page(
  title: none,
  subtitle: none,
  subsubtitle: none,
  subsubsubtitle: none,
  epigraph: none,
  author: none,
) = {
  place(horizon + center, dy: -15%, {
    set par(spacing: 0.7em, leading: 0.2em, justify: false)
    align(
      center,
      text(size: 4em, smallcaps(title), weight: "regular", hyphenate: false)
        + v(2.5%, weak: true)
        + if subtitle != none {
          text(size: 2em, smallcaps(subtitle))
          v(2.5%, weak: true)
        },
      )
      v(3.5%, weak: true)
      emph(text(size: 1.5em, subsubtitle))
      v(1.2%, weak: true)
      emph(subsubsubtitle)
  })

  {
    set par(justify: false, linebreaks: "optimized", spacing: 1em)
    set text(costs: (runt: 400%))
    set quote(block: true)
    show quote: it => [
      #emph(it.body)
      #align(right, box(text(size: 0.7em)[--- #it.attribution]))
    ]

    if epigraph != none {
      place(bottom + center, dy: -17.5%, block(
        stroke: (top: black, bottom: black),
        inset: (top: 12pt, bottom: 12pt, left: 6pt, right: 6pt),
        width: 80%,
        align(left, text(size: 1.4em, epigraph, hyphenate: false)),
      ))
    }
  }

  align(bottom + center, text(size: 1.5em, smallcaps(author)))
}

#let notes(
  title: none,
  author: none,
  subtitle: none,
  subsubtitle: none,
  subsubsubtitle: none,
  epigraph: none,
  body
) = {
  set text(font: "New Computer Modern")
  set par(first-line-indent: (amount : INDENT, all: false), justify: true,
          spacing: 0.5em + 1pt, leading: 0.5em + 1pt)
  set enum(indent: INDENT, numbering: "1")
  set terms(hanging-indent: INDENT)

  show math.equation: set block(breakable: true)
  show math.equation.where(block: false): it => box(it)

  set document(author: if author != none {author} else { () }, title: title)

  set page(
    margin: (left: 16.3%, right: 16.3%),
    footer: context {
      let current_chapter = query(selector(heading.where(level: 1).before(
        here()))).at(-1, default : none)
      let is_chapter_heading = current_chapter != none and current_chapter.location().page() == here().page()
      if not is_chapter_heading {
        return
      }

      let page = counter(page).display()
      set text(size: 9pt)
      place(center + horizon, page)
    },
    header: context {
      let page_num = counter(page).get().at(0)
      if page_num == 1 {
        return
      }

      let chapter_right_after = query(selector(heading.where(level: 1)).after(here())).at(0, default: none)
      let sec_right_after = query(selector(heading.where(level: 2)).after(here())).at(0, default: none)
      let sec_right_before = query(selector(heading.where(level: 2)).before(here())).at(-1, default: none)

      let current_chapter = query(selector(heading.where(level: 1)).before(here())).at(-1, default: none)
      let current_sec = if sec_right_after != none and sec_right_after.location().page() == here().page() {
        sec_right_after
      } else {
        sec_right_before
      }

      let is_chapter_heading = chapter_right_after != none and chapter_right_after.location().page() == here().page()

      if is_chapter_heading {
        return
      }

      let page = counter(page).display()
      let chap = if current_chapter != none {
        smallcaps(current_chapter.body)
      }
      let chap_num = if current_chapter != none [
        chap. #numbering(current_chapter.numbering, ..counter(heading).at(current_chapter.location()))
      ]

      let sec_num = if current_sec != none [
        sec. #numbering(current_sec.numbering, ..counter(heading).at(current_sec.location()))
      ]

      set text(size: 9pt)

      if calc.even(page_num) {
        place(left + horizon, page)
        place(center + horizon, smallcaps(title))
        if not is_chapter_heading {
          place(right + horizon, smallcaps(chap_num))
        }
      } else {
        if not is_chapter_heading {
          place(left + horizon, smallcaps(sec_num))
          place(center + horizon, chap)
        }
        place(right + horizon, page)
      }
    },
  )

  set footnote(numbering: n => numbering("*", n + 1))

  set math.equation(numbering: "(1)")
  show math.equation: it => {
    if it.block and not it.has("label") [
      #counter(math.equation).update(v => v - 1)
      #math.equation(it.body, block:true, numbering: none)#label("__NOLABEL")
    ] else {
      it
    }
  }

  show ref: it => {
    let eq = math.equation
    let el = it.element
    if el != none and el.func() == eq {
      link(el.location(), numbering(el.numbering, ..counter(eq).at(el.location())))
    } else {
      it
    }
  }

  show math.qed: "▮"

  show link: it => {
    if type(it.dest) != str {
      it
    } else if (it.body == [#it.dest]) {
      set text(fill: blue)
      set text(font: "DejaVu Sans Mono", size: 0.8em)
      box(it)
    } else {
      set text(fill: blue)
      show text: underline
      box(it)
    }
  }

  title-page(
    author: author,
    title: title,
    subtitle: subtitle,
    subsubtitle: subsubtitle,
    subsubsubtitle: subsubsubtitle,
    epigraph: epigraph
  )

  set heading(numbering: "1.1.1a")

  let heading-func = (body-fmt: strong, use-line: false, it) => {
    block(
      sticky: true,
      (
        emph(text(size: 0.8em, counter(heading).display()))
          + "."
          + h(0.5em)
          + body-fmt(it.body)
          + if use-line {
            box(width: 1fr, align(right, line(length: 100% - 0.8em, start: (0%, -0.225em), stroke: (
              paint:black,
              cap: "round",
            ))))
          }
      ),
    )
  }

  show heading.where(level: 2): heading-func.with(body-fmt: emph, use-line: true)
  show heading.where(level: 2): set text(size: 1.1em)
  show heading.where(level: 2): it => {
    set block(above: 0em, below: 0em)
    v(2em, weak: true) + it + v(1em, weak: true)
  }

  show heading.where(level: 3): heading-func
  show heading.where(level: 3): it => {
    set block(above: 0em, below: 0em)
    v(1.25em, weak: true) + it + v(0.75em, weak: true)
  }

  show heading.where(level: 4): heading-func

  show heading.where(level: 1): set heading(supplement: [Chapter])
  show heading.where(level: 1): it => {
    pagebreak(weak: true)
    set text(weight: "regular", hyphenate: false)
    set par(first-line-indent: 0.0em)
    counter(footnote).update(0)
    counter("notes-thmlike").update(0)
    counter("notes-example").update(0)

    counter(figure.where(kind: table)).update(0)

    block(
      inset: (left: -0.2em),
      height: 15% - 1em,
      {
        set text(size: 2em)
        (emph(it.body))
      }
        + if it.outlined {
          emph[
            #v(0.9em, weak: true)
            #h(0.125em)#smallcaps[Chapter] #counter(heading).display()
          ]
        },
    )
  }

  show enum: it => { v(0.9em, weak: true) + it + v(0.9em, weak: true) }

  show figure.where(kind: table): set figure.caption(position: top)
  show figure.where(kind: table): set figure(gap: 1em)
  show figure.where(kind:table): it => { v(1.5em, weak:true) + it + v(2em, weak: true) }

  pagebreak()
  body
}

#let thm-env(
  kind,
  fmt: it => it,
  body-fmt: it => it,
  numbered: true,
  counter-type: "thmlike"
) = {
  return (body, name: none, id: none, breakable: true) => {
    let ctr = counter("notes-" + counter-type)
    if numbered {
      ctr.step()
    }

    show figure: set align(start)
    show figure: it => it.body

    set enum(numbering: (..nums) => {
      let content = numbering("(1)", ..nums)
      if body-fmt == emph {
        emph(content)
      } else {
        content
      }
    })

    v(weak: true, 1.5em)
    [
      #block(width: 100%, breakable: breakable, above: 0em, below: 0em, [
        #figure(
          kind: kind,
          supplement: kind,
          numbering: (..levels) => [#counter(heading).get().at(0).#ctr.display()],
          {
            let number = context [ #counter(heading).get().at(0).#ctr.display()]
            (
              fmt[#kind#if numbered {number }] + if name != none [ *(#name)*] + fmt[.] + h(0.1em) + body-fmt(body)
            )
          },
        )#if id != none { label(id) }
      ])
    ]
    v(weak: true, 1.5em)
  }
}

#let smallcaps-strong = it => smallcaps(strong(it))

#let theorem = thm-env("Theorem", fmt: smallcaps-strong, body-fmt: emph)
#let proposition = thm-env("Proposition", fmt: smallcaps-strong, body-fmt: emph)
#let lemma = thm-env("Lemma", fmt: smallcaps-strong, body-fmt: emph)
#let corollary = thm-env("Corollary", fmt: smallcaps-strong, body-fmt: emph)
#let definition = thm-env("Definition", fmt: smallcaps-strong, body-fmt: emph)
#let example = thm-env("Example", fmt: it => strong(it), counter-type: "example")
#let solution = thm-env("Solution", fmt: emph, numbered: false)
#let proof = thm-env("Proof", fmt: emph, numbered: false)
#let remark = thm-env("Remark", fmt: it => strong(emph(it)), numbered: false)

#let glue(indent: true, body) = {
  block(sticky: true, (if indent { h(INDENT) }) + body)
}

#let tablef(..args) = {
  set table.hline(stroke: 0.5pt)
  table(
    align: left,
    stroke: (x,y) => {
      if (y==0) {
        (
          top: 1pt,
          bottom: 0.5pt
        )
      }
    },
    ..args.named(),
    ..(args.pos() + (table.hline(stroke: 1pt),)),
  )
}