//! Inline resolution pass 1: HTML, code spans, links, math, and the stacks
//! and link-label scanners they use.

///|
/// Handle inline markup.
fn Parser::handle_inline(self : Parser) -> Unit raise SyntaxError {
  self.handle_inline_pass1()
  self.handle_emphasis_and_hard_break()
}

///|
/// Handle inline HTML, code spans, and links.
fn Parser::handle_inline_pass1(self : Parser) -> Unit {
  let mut cur : Int32? = self.tree.cur()
  let mut prev : Int32? = None

  let block_end = self.tree.nodes[self.tree.peek_up().unwrap()].item.end
  let block_text = self.text.exact_view(start=0, end=block_end)

  while true {
    guard cur is Some(cur_ix) else { break }
    let mut cur_ix = cur_ix
    match self.tree.nodes[cur_ix].item.body {
      MaybeHtml => {
        let next = self.tree.nodes[cur_ix].next
        let autolink = next.bind(next_ix => {
          scan_autolink(block_text, self.tree.nodes[next_ix].item.start)
        })

        match autolink {
          Some((ix, uri, link_type)) => {
            let node = scan_nodes_to_ix(self.tree, next, ix)
            let text_node = self.tree.create_node(Item::{
              start: self.tree.nodes[cur_ix].item.start + 1,
              end: ix - 1,
              body: Text,
            })
            let link_ix = self.allocs.allocate_link(link_type, uri, "", "")
            self.tree.nodes[cur_ix].item.body = Link(link_ix)
            self.tree.nodes[cur_ix].item.end = ix
            self.tree.nodes[cur_ix].next = node
            self.tree.nodes[cur_ix].child = Some(text_node)
            prev = cur
            cur = node
            if cur is Some(node_ix) {
              self.tree.nodes[node_ix].item.start = self.tree.nodes[node_ix].item.start.max(
                ix,
              )
            }
            continue
          }
          None => {
            let inline_html = next.bind(next_ix => {
              self.scan_inline_html(
                block_text,
                self.tree.nodes[next_ix].item.start,
              )
            })
            guard inline_html is Some((span, ix)) else { () }
            let node = scan_nodes_to_ix(self.tree, next, ix)
            self.tree.nodes[cur_ix].item.body = if !span.is_empty() {
              let converted_string = @utf8.decode_lossy(
                Bytes::from_array(span).exact_view(),
              )
              OwnedInlineHtml(
                self.allocs.allocate_cow(replace_nuls(converted_string)),
              )
            } else {
              InlineHtml
            }
            self.tree.nodes[cur_ix].item.end = ix
            self.tree.nodes[cur_ix].next = node
            prev = cur
            cur = node
            if cur is Some(node_ix) {
              self.tree.nodes[node_ix].item.start = self.tree.nodes[node_ix].item.start.max(
                ix,
              )
            }
            continue
          }
        }
        self.tree.nodes[cur_ix].item.body = Text
      }
      MaybeMath(brace_context) => {
        let is_display = self.tree.nodes[cur_ix].next.map_or(false, next_ix => {
          self.tree.nodes[next_ix].item.body is MaybeMath(_)
        })
        let result = if self.math_delims.is_populated() {
          // we have previously scanned all math environment delimiters
          self.math_delims.find(self.tree, cur_ix, is_display, brace_context)
        } else {
          // we haven't previously scanned all math delimiters
          let mut scan = self.tree.nodes[cur_ix].next
          if is_display && scan is Some(s) {
            // a display delimiter, `$$`, is actually two delimiters
            scan = self.tree.nodes[s].next
          }
          let mut invalid = false
          while true {
            guard scan is Some(scan_ix) else { break }
            match self.tree.nodes[scan_ix].item.body {
              MaybeMath(delim_brace_context) => {
                let delim_is_display = self.tree.nodes[scan_ix].next.map_or(
                  false,
                  next_ix => self.tree.nodes[next_ix].item.body is MaybeMath(_),
                )
                let use_it = !invalid && delim_brace_context == brace_context
                if use_it {
                  if !is_display || delim_is_display {
                    // This will skip ahead past everything we just inserted.
                    self.math_delims.clear()
                    break
                  } else {
                    // Math cannot contain $, so the current item is invalid.
                    invalid = true
                  }
                }
                self.math_delims.insert(
                  delim_is_display, delim_brace_context, scan_ix,
                )
              }
              _ => ()
            }
            scan = self.tree.nodes[scan_ix].next
          }
          scan
        }

        if result is Some(scan_ix) {
          self.make_math_span(cur_ix, scan_ix)
        } else {
          self.tree.nodes[cur_ix].item.body = Text
        }
      }
      MaybeCode(search_count, preceded_by_backslash) => {
        let mut search_count = search_count
        if preceded_by_backslash {
          search_count -= 1
          guard search_count != 0 else {
            self.tree.nodes[cur_ix].item.body = Text
            prev = cur
            cur = self.tree.nodes[cur_ix].next
            continue
          }
        }

        if self.code_delims.is_populated() {
          // we have previously scanned all codeblock delimiters
          if self.code_delims.find(cur_ix, search_count) is Some(scan_ix) {
            self.make_code_span(cur_ix, scan_ix, preceded_by_backslash)
          } else {
            self.tree.nodes[cur_ix].item.body = Text
          }
        } else {
          // we haven't previously scanned all codeblock delimiters
          let mut scan = if search_count > 0 {
            self.tree.nodes[cur_ix].next
          } else {
            None
          }
          while true {
            guard scan is Some(scan_ix) else { break }
            match self.tree.nodes[scan_ix].item.body {
              MaybeCode(delim_count, _) =>
                if search_count == delim_count {
                  self.make_code_span(cur_ix, scan_ix, preceded_by_backslash)
                  self.code_delims.clear()
                  break
                } else {
                  self.code_delims.insert(delim_count, scan_ix)
                }
              _ => ()
            }
            scan = self.tree.nodes[scan_ix].next
          }
          if scan is None {
            self.tree.nodes[cur_ix].item.body = Text
          }
        }
      }
      MaybeLinkOpen => {
        self.tree.nodes[cur_ix].item.body = Text
        let link_open_doubled = self.tree.nodes[cur_ix].next.map_or(false, ix => {
          self.tree.nodes[ix].item.body is MaybeLinkOpen
        })
        if self.options.contains(enable_wikilinks()) && link_open_doubled {
          self.wikilink_stack.push(LinkStackEl::{ node: cur_ix, ty: Link, })
        }
        self.link_stack.push(LinkStackEl::{ node: cur_ix, ty: Link, })
      }
      MaybeImage => {
        self.tree.nodes[cur_ix].item.body = Text
        let link_open_doubled = self.tree.nodes[cur_ix].next.map_or(false, ix => {
          self.tree.nodes[ix].item.body is MaybeLinkOpen
        })
        if self.options.contains(enable_wikilinks()) && link_open_doubled {
          self.wikilink_stack.push(LinkStackEl::{ node: cur_ix, ty: Image, })
        }
        self.link_stack.push(LinkStackEl::{ node: cur_ix, ty: Image, })
      }
      MaybeLinkClose(could_be_ref) => {
        self.tree.nodes[cur_ix].item.body = Text
        let tos_link = self.link_stack.pop()
        let next_is_link_close = self.tree.nodes[cur_ix].next.map_or(false, ix => {
          self.tree.nodes[ix].item.body is MaybeLinkClose(_)
        })
        let is_wikilink_close = self.options.contains(enable_wikilinks()) &&
          next_is_link_close
        if is_wikilink_close {
          guard self.handle_wikilink(block_text, cur_ix, prev) is Some(node) else {
            ()
          }
          prev = Some(node)
          cur = self.tree.nodes[node].next
          continue
        }
        guard tos_link is Some(tos) else { () }
        // skip rendering if already in a link, unless its an image
        let parent_is_link = self.tree.nodes[self.tree.peek_up().unwrap()].item.body
          is Link(_)
        let in_link = !(tos.ty is Image) && parent_is_link
        guard !in_link else { continue }
        guard !(tos.ty is Disabled) else { continue }
        let next = self.tree.nodes[cur_ix].next
        match
          self.scan_inline_link(
            block_text,
            self.tree.nodes[cur_ix].item.end,
            next,
          ) {
          Some((next_ix, url, title)) => {
            let next_node = scan_nodes_to_ix(self.tree, next, next_ix)
            if prev is Some(prev_ix) {
              self.tree.nodes[prev_ix].next = None
            }
            cur = Some(tos.node)
            cur_ix = tos.node
            let link_ix = self.allocs.allocate_link(Inline, url, title, "")
            self.tree.nodes[cur_ix].item.body = if tos.ty is Image {
              Image(link_ix)
            } else {
              Link(link_ix)
            }
            self.tree.nodes[cur_ix].child = self.tree.nodes[cur_ix].next
            self.tree.nodes[cur_ix].next = next_node
            self.tree.nodes[cur_ix].item.end = next_ix
            if next_node is Some(next_node_ix) {
              self.tree.nodes[next_node_ix].item.start = self.tree.nodes[next_node_ix].item.start.max(
                next_ix,
              )
            }

            if tos.ty is Link {
              self.disable_all_links()
            }
          }
          None => {
            // ok, so its not an inline link. maybe it is a reference
            let scan_result = scan_reference(
              self.tree,
              block_text,
              cur_ix,
              self.options,
            )
            let (node_after_link, link_type) = match scan_result {
              // [label][reference]
              RefScan::LinkLabel(_, end_ix) => {
                guard scan_nodes_to_ix(self.tree, next, end_ix - 1)
                  is Some(reference_close_node) else {
                  continue
                }
                self.tree.nodes[reference_close_node].item.body = MaybeLinkClose(
                  false,
                )
                let next_node = self.tree.nodes[reference_close_node].next

                (next_node, Reference)
              }
              // [reference][]
              RefScan::Collapsed(next_node) => {
                guard could_be_ref else { continue }
                (next_node, Collapsed)
              }
              // [shortcut]
              RefScan::Failed | RefScan::UnexpectedFootnote => {
                guard could_be_ref else { continue }
                (next, Shortcut)
              }
            }

            let label : (ReferenceLabel, Int32)? = match scan_result {
              RefScan::LinkLabel(l, end_ix) =>
                Some((ReferenceLabel::Link(l), end_ix))
              RefScan::Collapsed(_)
              | RefScan::Failed
              | RefScan::UnexpectedFootnote => {
                // No label? maybe it is a shortcut reference
                let label_start = self.tree.nodes[tos.node].item.end - 1
                let label_end = self.tree.nodes[cur_ix].item.end
                scan_link_label(
                  self.tree,
                  self.text.exact_view(start=label_start, end=label_end),
                  self.options,
                ).bind(result => {
                  let (ix, label) = result
                  guard label_start + ix == label_end else { None }
                  Some((label, label_start + ix))
                })
              }
            }

            let id = label.map_or("", entry => {
              let (label, _) = entry
              match label {
                ReferenceLabel::Link(l) | ReferenceLabel::Footnote(l) => l
              }
            })

            // see if it's a footnote reference
            guard label is Some(label) else { () }
            match label {
              (ReferenceLabel::Footnote(l), end) => {
                let footref = self.allocs.allocate_cow(l)
                if self.allocs.footdefs.contains(l) {
                  let def = self.allocs.footdefs[l]
                  def._use_count += 1
                  self.allocs.footdefs[l] = def
                }
                let should_emit = !self.options.options_has_gfm_footnotes() ||
                  self.allocs.footdefs.contains(l)
                if should_emit {
                  let footnote_ix = if tos.ty is Image {
                    self.tree.nodes[tos.node].next = Some(cur_ix)
                    self.tree.nodes[tos.node].child = None
                    self.tree.nodes[tos.node].item.body = SynthesizeChar('!')
                    self.tree.nodes[cur_ix].item.start = self.tree.nodes[tos.node].item.start +
                      1
                    self.tree.nodes[tos.node].item.end = self.tree.nodes[tos.node].item.start +
                      1
                    cur_ix
                  } else {
                    tos.node
                  }
                  self.tree.nodes[footnote_ix].next = next
                  self.tree.nodes[footnote_ix].child = None
                  self.tree.nodes[footnote_ix].item.body = FootnoteReference(
                    footref,
                  )
                  self.tree.nodes[footnote_ix].item.end = end
                  prev = Some(footnote_ix)
                  cur = next
                  self.link_stack.clear()
                  continue
                }
              }
              (ReferenceLabel::Link(link_label), end) =>
                if self.fetch_link_type_url_title(
                    link_label,
                    (self.tree.nodes[tos.node].item.start, end),
                    link_type,
                  )
                  is Some((def_link_type, url, title)) {
                  let link_ix = self.allocs.allocate_link(
                    def_link_type, url, title, id,
                  )
                  self.tree.nodes[tos.node].item.body = if tos.ty is Image {
                    Image(link_ix)
                  } else {
                    Link(link_ix)
                  }
                  let label_node = self.tree.nodes[tos.node].next

                  // lets do some tree surgery to add the link to the tree
                  self.tree.nodes[tos.node].next = node_after_link

                  if label_node != cur {
                    self.tree.nodes[tos.node].child = label_node

                    // finally: disconnect list of children
                    if prev is Some(prev_ix) {
                      self.tree.nodes[prev_ix].next = None
                    }
                  }

                  self.tree.nodes[tos.node].item.end = end

                  // set up cur so next node will be node_after_link
                  cur = Some(tos.node)
                  cur_ix = tos.node

                  if tos.ty is Link {
                    self.disable_all_links()
                  }
                }
            }
          }
        }
      }
      _ => ()
    }
    prev = cur
    cur = self.tree.nodes[cur_ix].next
  }
  self.link_stack.clear()
  self.wikilink_stack.clear()
  self.code_delims.clear()
  self.math_delims.clear()
}

///|
priv enum ReferenceLabel {
  Link(String)
  Footnote(String)
}

///|
priv enum RefScan {
  // label, source ix of label end
  LinkLabel(String, Int32)
  // contains next node index
  Collapsed(Int32?)
  UnexpectedFootnote
  Failed
}

///|
/// Skips forward within a block to a node which spans (ends inclusive) the given
/// index into the source.
fn scan_nodes_to_ix(tree : Tree[Item], node : Int32?, ix : Int32) -> Int32? {
  for node = node {
    guard node is Some(node_ix) && tree.nodes[node_ix].item.end <= ix else {
      break node
    }
    continue tree.nodes[node_ix].next
  }
}

///|
/// Scans an inline link label, which cannot be interrupted.
fn scan_link_label(
  tree : Tree[Item],
  text : BytesView,
  options : Options,
) -> (Int32, ReferenceLabel)? {
  let bytes = text
  guard bytes.length() >= 2 && bytes.unsafe_get(0) == b'[' else { return None }
  let is_footnote = options.contains(enable_footnotes()) &&
    bytes.length() > 2 &&
    bytes.unsafe_get(1) == b'^' &&
    bytes.unsafe_get(2) != b']'
  if is_footnote {
    let handler : ((BytesView) -> Int32?)? = if options.options_has_gfm_footnotes() {
      None
    } else {
      Some((bytes : BytesView) => {
        Some(skip_container_prefixes(tree, bytes, options))
      })
    }
    guard scan_link_label_rest(text, 2, handler, tree.is_in_table())
      is Some((byte_index, cow)) else {
      ()
    }
    return Some((byte_index + 2, ReferenceLabel::Footnote(cow)))
  }
  let handler : ((BytesView) -> Int32?)? = Some((bytes : BytesView) => {
    Some(skip_container_prefixes(tree, bytes, options))
  })
  scan_link_label_rest(text, 1, handler, tree.is_in_table()).map(label => {
    let (byte_index, cow) = label
    (byte_index + 1, ReferenceLabel::Link(cow))
  })
}

///|
fn scan_reference(
  tree : Tree[Item],
  text : BytesView,
  cur_ix : Int32,
  options : Options,
) -> RefScan {
  let start = tree.nodes[cur_ix].item.end
  let tail = text.exact_view(start~)

  if tail.has_prefix(b"[]".exact_view()) {
    guard tree.nodes[cur_ix].next is Some(next_ix) &&
      tree.nodes[next_ix].item.start == tree.nodes[cur_ix].item.end else {
      return RefScan::Failed
    }
    guard tree.nodes[next_ix].next is Some(closing_node) else {
      return RefScan::Failed
    }
    RefScan::Collapsed(tree.nodes[closing_node].next)
  } else {
    guard scan_link_label(tree, text.exact_view(start~), options)
      is Some((ix, label)) else {
      return RefScan::Failed
    }
    match label {
      ReferenceLabel::Link(label) => RefScan::LinkLabel(label, start + ix)
      ReferenceLabel::Footnote(_) => RefScan::UnexpectedFootnote
    }
  }
}

///|
fn replace_nuls(s : String) -> String {
  s.replace_all(old="\u{0}", new="\u{fffd}")
}

///|
priv struct LinkStackEl {
  node : Int32
  mut ty : LinkStackTy
}

///|
priv enum LinkStackTy {
  Link
  Image
  Disabled
}

///|
struct LinkStack {
  inner : Array[LinkStackEl]
  mut disabled_ix : Int32
}

///|
fn link_stack_new() -> LinkStack {
  { inner: [], disabled_ix: 0, }
}

///|
fn LinkStack::push(self : LinkStack, el : LinkStackEl) -> Unit {
  self.inner.push(el)
}

///|
fn LinkStack::pop(self : LinkStack) -> LinkStackEl? {
  let el = self.inner.pop()
  self.disabled_ix = self.disabled_ix.min(self.inner.length())
  el
}

///|
fn LinkStack::clear(self : LinkStack) -> Unit {
  self.inner.clear()
  self.disabled_ix = 0
}

///|
fn LinkStack::disable_all_links(self : LinkStack) -> Unit {
  for i in self.disabled_ix..