//! HTML Converter
//!
//! Converts the Org AST to its HTML representation.

use org_rust_parser as org_parser;

use core::fmt;
use std::borrow::Cow;
use std::collections::{HashMap, HashSet};
use std::fmt::{Result, Write};

use latex2mathml::{latex_to_mathml, DisplayStyle};
use memchr::memchr3_iter;
use org_parser::element::{Affiliated, Block, CheckBox, ListKind, TableRow};
use org_parser::parse_macro_call;
use org_parser::types::{Expr, Node, Parser};

use crate::org_macros::macro_handle;
use crate::types::Exporter;
use org_parser::node_pool::NodeID;
use org_parser::object::{LatexFragment, PathReg, PlainOrRec};
use org_parser::parse_org;
use phf::phf_set;

const BACKEND_NAME: &str = "html";

// file types we can wrap an `img` around
static IMAGE_TYPES: phf::Set<&str> = phf_set! {
    "jpeg",
    "jpg",
    "png",
    "gif",
    "svg",
    "webp",
};

pub struct Html<'buf> {
    buf: &'buf mut dyn fmt::Write,
    // HACK: When we export a caption, insert the child id here to make sure
    // it's not double exported
    nox: HashSet<NodeID>, // no-export
    // used footnotes
    footnotes: Vec<NodeID>,
    footnote_ids: HashMap<NodeID, usize>,
}

/// Wrapper around strings that need to be properly HTML escaped.
pub(crate) struct HtmlEscape<'a>(pub &'a str);

impl<'a> fmt::Display for HtmlEscape<'a> {
    // design based on:
    // https://lise-henry.github.io/articles/optimising_strings.html
    // we can iterate over bytes since it's not possible for
    // an ascii character to appear in the codepoint of another larger char
    // if we see an ascii, then it's guaranteed to be valid
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result {
        let mut prev_pos = 0;
        // there are other characters we could escape, but memchr caps out at 3
        // the really important one is `<`, and then also probably &
        // throwing in `>` for good measure
        // based on:
        // https://mina86.com/2021/no-you-dont-need-to-escape-that/
        // there are invariants in the parsing (i hope) that should make
        // using memchr3 okay. if not, consider using jetscii for more byte blasting

        let escape_bytes = memchr3_iter(b'<', b'&', b'>', self.0.as_bytes());

        for ret in escape_bytes {
            write!(f, "{}", &self.0[prev_pos..ret])?;

            match self.0.as_bytes()[ret] {
                b'<' => write!(f, r"&lt;")?,
                b'>' => write!(f, r"&gt;")?,
                b'&' => write!(f, r"&amp;")?,
                _ => unreachable!(),
            }
            prev_pos = ret + 1;
        }

        write!(f, "{}", &self.0[prev_pos..])
    }
}

impl<'buf> Exporter<'buf> for Html<'buf> {
    fn export(input: &str) -> core::result::Result<String, fmt::Error> {
        let mut buf = String::new();
        Html::export_buf(input, &mut buf)?;
        Ok(buf)
    }

    fn export_buf<'inp, T: fmt::Write>(
        input: &'inp str,
        buf: &'buf mut T,
    ) -> core::result::Result<&'buf mut T, fmt::Error> {
        let parsed = parse_org(input);
        let mut obj = Html {
            buf,
            nox: HashSet::new(),
            footnotes: Vec::new(),
            footnote_ids: HashMap::new(),
        };

        obj.export_rec(&parsed.pool.root_id(), &parsed)?;
        obj.exp_footnotes(&parsed)?;
        Ok(buf)
    }

    fn export_macro_buf<'inp, T: fmt::Write>(
        input: &'inp str,
        buf: &'buf mut T,
    ) -> core::result::Result<&'buf mut T, fmt::Error> {
        let parsed = parse_macro_call(input);
        let mut obj = Html {
            buf,
            nox: HashSet::new(),
            footnotes: Vec::new(),
            footnote_ids: HashMap::new(),
        };

        obj.export_rec(&parsed.pool.root_id(), &parsed)?;
        Ok(buf)
    }

    fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) -> Result {
        // avoid parsing this node
        if self.nox.contains(node_id) {
            return Ok(());
        }
        let node = &parser.pool[*node_id];
        match &node.obj {
            Expr::Root(inner) => {
                for id in inner {
                    self.export_rec(id, parser)?;
                }
            }
            Expr::Heading(inner) => {
                let heading_number: u8 = inner.heading_level.into();

                write!(self, "<h{heading_number}",)?;
                self.prop(node)?;
                write!(self, ">")?;

                if let Some(title) = &inner.title {
                    for id in &title.1 {
                        self.export_rec(id, parser)?;
                    }
                }

                writeln!(self, "</h{heading_number}>")?;

                if let Some(children) = &inner.children {
                    for id in children {
                        self.export_rec(id, parser)?;
                    }
                }
            }
            Expr::Block(inner) => {
                match inner {
                    // Greater Blocks
                    Block::Center {
                        parameters: _,
                        contents,
                    } => {
                        write!(self, "<div")?;
                        self.class("center")?;
                        self.prop(node)?;
                        writeln!(self, ">")?;
                        for id in contents {
                            self.export_rec(id, parser)?;
                        }
                        writeln!(self, "</div>")?;
                    }
                    Block::Quote {
                        parameters: _,
                        contents,
                    } => {
                        write!(self, "<blockquote")?;
                        self.prop(node)?;
                        writeln!(self, ">")?;
                        for id in contents {
                            self.export_rec(id, parser)?;
                        }
                        writeln!(self, "</blockquote>")?;
                    }
                    Block::Special {
                        parameters: _,
                        contents,
                        name,
                    } => {
                        write!(self, "<div")?;
                        self.prop(node)?;
                        self.class(name)?;
                        writeln!(self, ">")?;
                        for id in contents {
                            self.export_rec(id, parser)?;
                        }
                        writeln!(self, "</div>")?;
                    }

                    // Lesser blocks
                    Block::Comment {
                        parameters: _,
                        contents,
                    } => {
                        writeln!(self, "<!--{contents}-->")?;
                    }
                    Block::Example {
                        parameters: _,
                        contents,
                    } => {
                        write!(self, "<pre")?;
                        self.class("example")?;
                        self.prop(node)?;
                        writeln!(self, ">\n{}</pre>", HtmlEscape(contents))?;
                    }
                    Block::Export {
                        parameters,
                        contents,
                    } => {
                        if let Some(params) = parameters {
                            if params.contains(BACKEND_NAME) {
                                writeln!(self, "{contents}")?;
                            }
                        }
                    }
                    Block::Src {
                        parameters: _,
                        contents,
                    } => {
                        // TODO: work with the language parameter
                        write!(self, "<pre")?;
                        self.class("src")?;
                        self.prop(node)?;
                        writeln!(self, ">\n{}</pre>", HtmlEscape(contents))?;
                    }
                    Block::Verse {
                        parameters: _,
                        contents,
                    } => {
                        // FIXME: apparently verse blocks contain objects...
                        write!(self, "<p")?;
                        self.class("verse")?;
                        self.prop(node)?;
                        writeln!(self, ">\n{}</p>", HtmlEscape(contents))?;
                    }
                }
            }
            Expr::RegularLink(inner) => {
                let path_link: String = match inner.path.obj {
                    PathReg::PlainLink(a) => a.into(),
                    PathReg::Id(a) => format!("#{a}"),
                    PathReg::CustomId(a) => format!("#{a}"),
                    PathReg::Coderef(_) => todo!(),
                    PathReg::Unspecified(a) => {
                        let mut rita = String::new();
                        for (match_targ, ret) in parser.targets.iter() {
                            if match_targ.starts_with(a) {
                                rita = format!("#{ret}");
                                break;
                            }
                        }
                        // TODO: how to handle non-existing links
                        rita
                    }
                };
                write!(self, r#"<a href="{}">"#, HtmlEscape(&path_link))?;
                if let Some(children) = &inner.description {
                    for id in children {
                        self.export_rec(id, parser)?;
                    }
                } else {
                    write!(self, "{}", HtmlEscape(inner.path.to_str(parser.source)))?;
                }
                write!(self, "</a>")?;
            }

            Expr::Paragraph(inner) => {
                if inner.0.len() == 1 {
                    if let Expr::RegularLink(link) = &parser.pool[inner.0[0]].obj {
                        let link_source = link.path.to_str(parser.source);
                        let ending_tag = link_source.split('.').last();
                        if let Some(extension) = ending_tag {
                            if IMAGE_TYPES.contains(extension) {
                                write!(self, "<figure>\n<img")?;
                                self.prop(node)?;
                                write!(self, r#" src="{}""#, HtmlEscape(link_source))?;
                                write!(self, r#" alt=""#)?;
                                if let Some(children) = &link.description {
                                    for id in children {
                                        self.export_rec(id, parser)?;
                                    }
                                } else {
                                    let alt_text =
                                        if let Some(slashed) = link_source.split('/').last() {
                                            slashed
                                        } else {
                                            link_source
                                        };
                                    write!(self, "{}", HtmlEscape(alt_text))?;
                                }
                                write!(self, "\">\n</figure>")?;
                                return Ok(());
                            }
                        }
                    }
                }
                write!(self, "<p")?;
                self.prop(node)?;
                writeln!(self, ">")?;

                for id in &inner.0 {
                    self.export_rec(id, parser)?;
                }
                writeln!(self, "\n</p>")?;
            }

            Expr::Italic(inner) => {
                write!(self, "<em>")?;
                for id in &inner.0 {
                    self.export_rec(id, parser)?;
                }
                write!(self, "</em>")?;
            }
            Expr::Bold(inner) => {
                write!(self, "<b>")?;
                for id in &inner.0 {
                    self.export_rec(id, parser)?;
                }
                write!(self, "</b>")?;
            }
            Expr::StrikeThrough(inner) => {
                write!(self, "<del>")?;
                for id in &inner.0 {
                    self.export_rec(id, parser)?;
                }
                write!(self, "</del>")?;
            }
            Expr::Underline(inner) => {
                write!(self, "<u>")?;
                for id in &inner.0 {
                    self.export_rec(id, parser)?;
                }
                write!(self, "</u>")?;
                // write!(self, "<span class=underline>")?;
                // for id in &inner.0 {
                //     self.export_rec(id, parser)?;
                // }
                // write!(self, "</span>")?;
            }
            Expr::BlankLine => {
                // write!(self, "\n")?;
            }
            Expr::SoftBreak => {
                write!(self, " ")?;
            }
            Expr::LineBreak => {
                writeln!(self, "\n<br>")?;
            }
            Expr::HorizontalRule => {
                writeln!(self, "\n<hr>")?;
            }
            Expr::Plain(inner) => {
                write!(self, "{}", HtmlEscape(inner))?;
            }
            Expr::Verbatim(inner) => {
                write!(self, "<code>{}</code>", HtmlEscape(inner.0))?;
            }
            Expr::Code(inner) => {
                write!(self, "<code>{}</code>", HtmlEscape(inner.0))?;
            }
            Expr::Comment(inner) => {
                write!(self, "<!--{}-->", inner.0)?;
            }
            Expr::InlineSrc(inner) => {
                write!(
                    self,
                    "<code class={}>{}</code>",
                    inner.lang,
                    HtmlEscape(inner.body)
                )?;
                // if let Some(args) = inner.headers {
                //     write!(self, "[{args}]")?;
                // }
                // write!(self, "{{{}}}", inner.body)?;
            }
            Expr::Keyword(_) => {
                // todo!()
                // match inner {
                //     Keyword::Basic { key, val } => {
                //         if ORG_AFFILIATED_KEYWORDS.contains(key) {
                //             todo!()
                //         }
                //     }
                //     Keyword::Macro(_) => todo!(),
                //     Keyword::Affilliated(_) => todo!(),
                // }
            }
            Expr::LatexEnv(inner) => {
                let ret = latex_to_mathml(
                    &format!(
                        r"\begin{{{0}}}
{1}
\end{{{0}}}
",
                        inner.name, inner.contents
                    ),
                    DisplayStyle::Block,
                )
                .unwrap();
                writeln!(self, "{ret}")?;
            }
            Expr::LatexFragment(inner) => match inner {
                LatexFragment::Command { name, contents } => {
                    let mut pot_cont = String::new();
                    write!(pot_cont, r#"{name}"#)?;
                    if let Some(command_cont) = contents {
                        write!(pot_cont, "{{{command_cont}}}")?;
                    }
                    write!(
                        self,
                        "{}",
                        &latex_to_mathml(&pot_cont, DisplayStyle::Inline).unwrap(),
                    )?;
                }
                LatexFragment::Display(inner) => {
                    writeln!(
                        self,
                        "{}",
                        &latex_to_mathml(inner, DisplayStyle::Block).unwrap()
                    )?;
                }
                LatexFragment::Inline(inner) => {
                    write!(
                        self,
                        "{}",
                        &latex_to_mathml(inner, DisplayStyle::Inline).unwrap()
                    )?;
                }
            },
            Expr::Item(inner) => {
                if let Some(tag) = inner.tag {
                    write!(self, "<dt>{}</dt>", HtmlEscape(tag))?;
                    write!(self, "<dd>")?;
                    for id in &inner.children {
                        self.export_rec(id, parser)?;
                    }
                    write!(self, "</dd>")?;
                } else {
                    write!(self, "<li")?;

                    if let Some(counter) = inner.counter_set {
                        self.attr("value", counter)?;
                    }

                    if let Some(check) = &inner.check_box {
                        self.class(match check {
                            CheckBox::Intermediate => "trans",
                            CheckBox::Off => "off",
                            CheckBox::On => "on",
                        })?;
                    }

                    write!(self, ">")?;

                    for id in &inner.children {
                        self.export_rec(id, parser)?;
                    }

                    writeln!(self, "</li>")?;
                }
            }
            Expr::PlainList(inner) => {
                let tag = match inner.kind {
                    ListKind::Unordered => "ul",
                    ListKind::Ordered(_) => "ol",
                    ListKind::Descriptive => "dd",
                };
                write!(self, "<{tag}")?;
                self.prop(node)?;
                writeln!(self, ">")?;
                for id in &inner.children {
                    self.export_rec(id, parser)?;
                }
                writeln!(self, "</{tag}>")?;
            }
            Expr::PlainLink(inner) => {
                write!(
                    self,
                    "<a href={0}:{1}>{0}:{1}</a>",
                    inner.protocol, inner.path
                )?;
            }
            Expr::Entity(inner) => {
                write!(self, "{}", inner.mapped_item)?;
            }
            Expr::Table(inner) => {
                write!(self, "<table")?;
                self.prop(node)?;
                writeln!(self, ">")?;

                for id in &inner.children {
                    self.export_rec(id, parser)?;
                }

                writeln!(self, "</table>")?;
            }

            Expr::TableRow(inner) => {
                match inner {
                    TableRow::Rule => { /*skip*/ }
                    TableRow::Standard(stands) => {
                        writeln!(self, "<tr>")?;
                        for id in stands.iter() {
                            self.export_rec(id, parser)?;
                        }
                        writeln!(self, "</tr>")?;
                    }
                }
            }
            Expr::TableCell(inner) => {
                write!(self, "<td>")?;
                for id in &inner.0 {
                    self.export_rec(id, parser)?;
                }
                writeln!(self, "</td>")?;
            }
            Expr::Emoji(inner) => {
                write!(self, "{}", inner.mapped_item)?;
            }
            Expr::Superscript(inner) => {
                write!(self, "<sup>")?;
                match &inner.0 {
                    PlainOrRec::Plain(inner) => {
                        write!(self, "{inner}")?;
                    }
                    PlainOrRec::Rec(inner) => {
                        for id in inner {
                            self.export_rec(id, parser)?;
                        }
                    }
                }
                write!(self, "</sup>")?;
            }
            Expr::Subscript(inner) => {
                write!(self, "<sub>")?;
                match &inner.0 {
                    PlainOrRec::Plain(inner) => {
                        write!(self, "{inner}")?;
                    }
                    PlainOrRec::Rec(inner) => {
                        for id in inner {
                            self.export_rec(id, parser)?;
                        }
                    }
                }
                write!(self, "</sub>")?;
            }
            Expr::Target(inner) => {
                write!(self, "<span")?;
                self.prop(node)?;
                write!(self, ">")?;
                write!(
                    self,
                    "<span id={}>{}</span>",
                    parser.pool[*node_id].id_target.as_ref().unwrap(), // must exist
                    HtmlEscape(inner.0)
                )?;
            }
            Expr::Macro(macro_call) => {
                if let Ok(macro_contents) = macro_handle(parser, macro_call) {
                    match macro_contents {
                        Cow::Owned(p) => {
                            Html::export_macro_buf(&p, self)?;
                        }
                        Cow::Borrowed(r) => {
                            write!(self, "{}", HtmlEscape(r))?;
                        }
                    }
                }
            }
            Expr::Drawer(inner) => {
                for id in &inner.children {
                    self.export_rec(id, parser)?;
                }
            }
            Expr::ExportSnippet(inner) => {
                if inner.backend == BACKEND_NAME {
                    write!(self, "{}", inner.contents)?;
                }
            }
            Expr::Affiliated(inner) => match inner {
                Affiliated::Name(_id) => {}
                Affiliated::Caption(id, contents) => {
                    if let Some(caption_id) = id {
                        writeln!(self, "<figure>")?;
                        writeln!(self, "<figcaption>{contents}</figcaption>")?;
                        self.export_rec(caption_id, parser)?;
                        writeln!(self, "</figure>")?;
                        self.nox.insert(*caption_id);
                    }
                }
                Affiliated::Attr { .. } => {}
            },
            Expr::MacroDef(_) => {}
            Expr::FootnoteDef(_) => {
                // handled after root
            }
            Expr::FootnoteRef(inner) => {
                let foot_len = self.footnotes.len();
                let target_id = if let Some(label) = inner.label {
                    if let Some(def_id) = parser.footnotes.get(label) {
                        *def_id
                    } else {
                        *node_id
                    }
                } else {
                    *node_id
                };

                let index = *self.footnote_ids.entry(target_id).or_insert_with(|| {
                    self.footnotes.push(target_id);
                    foot_len + 1
                });

                // prevent duplicate ids:
                // node ids are guaranteed to be unique
                let fn_id = if index != foot_len + 1 {
                    format!("{index}.{node_id}")
                } else {
                    format!("{index}")
                };

                write!(
                    self,
                    r##"<sup>
    <a id="fnr.{0}" href="#fn.{1}" class="footref" role="doc-backlink">{1}</a>
</sup>"##,
                    fn_id, index,
                )?;
            }
        }

        Ok(())
    }
}

impl<'buf> Html<'buf> {
    fn prop(&mut self, node: &Node) -> Result {
        if let Some(tag_contents) = node.id_target.as_ref() {
            write!(self, r#" id="{tag_contents}""#)?;
        }

        if let Some(attrs) = node.attrs.get(BACKEND_NAME) {
            for item in attrs {
                self.attr(item.key, item.val)?;
            }
        }

        Ok(())
    }

    fn class(&mut self, name: &str) -> Result {
        write!(self, r#" class="{name}""#)
    }

    fn attr(&mut self, key: &str, val: &str) -> Result {
        write!(self, r#" {}="{}""#, key, HtmlEscape(val))
    }

    fn exp_footnotes(&mut self, parser: &Parser) -> Result {
        if self.footnotes.is_empty() {
            return Ok(());
        }

        // get last heading, and check if its title is Footnotes,
        // if so, destroy it
        let heading_query = parser.pool.iter().rev().find(|node| {
            if let Expr::Heading(head) = &node.obj {
                if let Some(title) = &head.title {
                    if title.0 == "Footnotes\n" {
                        return true;
                    }
                }
            }
            false
        });

        writeln!(
            self,
            r#"
<div id="footnotes">
    <style>
    .footdef p {{
    display:inline;
    }}
    </style>"#
        )?;

        if heading_query.is_none() {
            writeln!(self, r#"    <h2 class="footnotes">Footnotes</h2>"#)?;
        }

        writeln!(self, r#"    <div id="text-footnotes">"#)?;

        // FIXME
        // lifetime shenanigans making me do this.. can't figure em out
        // would like to self.footnotes.iter(), but we get multiple
        // immutable borrows, so self.footnotes.copied.iter(), but still no go
        let man = self.footnotes.clone();
        for (mut pos, def_id) in man.iter().enumerate() {
            pos += 1;
            write!(
                self,
                r##"

<div class="footdef">
<sup>
    <a id="fn.{pos}" href= "#fnr.{pos}" role="doc-backlink">{pos}</a>
</sup>
"##
            )?;
            match &parser.pool[*def_id].obj {
                Expr::FootnoteDef(fn_def) => {
                    for child_id in &fn_def.children {
                        self.export_rec(child_id, parser)?;
                    }
                }
                Expr::FootnoteRef(fn_ref) => {
                    if let Some(children) = fn_ref.children.as_ref() {
                        for child_id in children {
                            self.export_rec(child_id, parser)?;
                        }
                    }
                }
                _ => (),
            }
            write!(self, r#"</div>"#)?;
        }
        write!(self, "\n  </div>\n</div>")
    }
}

impl fmt::Write for Html<'_> {
    fn write_str(&mut self, s: &str) -> Result {
        self.buf.write_str(s)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    // use pretty_assertions::{assert_eq, assert_ne};
    use pretty_assertions::assert_eq;

    #[test]
    fn combined_macros() -> fmt::Result {
        let a = Html::export(
            r"#+macro: poem hiii $1 $2 text
{{{poem(cool,three)}}}
",
        )?;

        assert_eq!(
            a,
            r"<p>
hiii cool three text
</p>
"
        );

        Ok(())
    }

    #[test]
    fn keyword_macro() -> Result {
        let a = Html::export(
            r"
     #+title: hiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
{{{keyword(title)}}}
",
        )?;

        assert_eq!(
            a,
            r"<p>
hiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
</p>
"
        );
        Ok(())
    }

    #[test]
    fn line_break() -> Result {
        let a = Html::export(
            r" abc\\
",
        )?;

        assert_eq!(
            a,
            r"<p>
abc
<br>

</p>
"
        );

        let n = Html::export(
            r" abc\\   q
",
        )?;

        assert_eq!(
            n,
            r"<p>
abc\\   q
</p>
"
        );
        Ok(())
    }

    #[test]
    fn horizontal_rule() -> Result {
        let a = Html::export(
            r"-----
",
        )?;

        let b = Html::export(
            r"                -----
",
        )?;

        let c = Html::export(
            r"      -------------------------
",
        )?;

        assert_eq!(a, b);
        assert_eq!(b, c);
        assert_eq!(a, c);

        let nb = Html::export(
            r"                ----
",
        )?;

        assert_eq!(
            nb,
            r"<p>
----
</p>
"
        );

        Ok(())
    }

    #[test]
    fn correct_cache() -> Result {
        let a = Html::export(
            r"
- one
- two

\begin{align}
abc &+ 10\\
\end{align}
",
        )?;
        println!("{a}");

        Ok(())
    }

    #[test]
    fn html_unicode() -> Result {
        let a = Html::export(
            r"a é😳
",
        )?;

        assert_eq!(
            a,
            r"<p>
a é😳
</p>
"
        );

        Ok(())
    }

    #[test]
    fn list_counter_set() -> Result {
        let a = Html::export(
            r"
1. [@4] wordsss??
",
        )?;

        assert_eq!(
            a,
            r#"<ol>
<li value="4"><p>
wordsss??
</p>
</li>
</ol>
"#
        );
        Ok(())
    }
    #[test]
    fn anon_footnote() -> Result {
        let a = Html::export(
            r"
hi [fn:next:coolio]
",
        )?;
        // just codifying what the output is here, not supposed to be set in stone
        assert_eq!(
            a,
            r##"<p>
hi <sup>
    <a id="fnr.1" href="#fn.1" class="footref" role="doc-backlink">1</a>
</sup>
</p>

<div id="footnotes">
    <style>
    .footdef p {
    display:inline;
    }
    </style>
    <h2 class="footnotes">Footnotes</h2>
    <div id="text-footnotes">


<div class="footdef">
<sup>
    <a id="fn.1" href= "#fnr.1" role="doc-backlink">1</a>
</sup>
coolio</div>
  </div>
</div>"##
        );
        Ok(())
    }

    #[test]
    fn footnote_heading() -> Result {
        let a = Html::export(
            r"
hello [fn:1]

* Footnotes

[fn:1] world
",
        )?;

        // just codifying what the output is here, not supposed to be set in stone
        assert_eq!(
            a,
            r##"<p>
hello <sup>
    <a id="fnr.1" href="#fn.1" class="footref" role="doc-backlink">1</a>
</sup>
</p>
<h1 id="footnotes">Footnotes</h1>

<div id="footnotes">
    <style>
    .footdef p {
    display:inline;
    }
    </style>
    <div id="text-footnotes">


<div class="footdef">
<sup>
    <a id="fn.1" href= "#fnr.1" role="doc-backlink">1</a>
</sup>
<p>
world
</p>
</div>
  </div>
</div>"##
        );
        Ok(())
    }

    #[test]
    fn footnote_order() -> Result {
        // tests dupes too
        let a = Html::export(
            r#"
hi [fn:dupe] cool test [fn:coolnote]  [fn:dupe:inlinefootnote]
coolest [fn:1] again [fn:1]

novel [fn:next:coolio]


** Footnotes

[fn:1] hi
[fn:dupe] abcdef
[fn:coolnote] words babby

"#,
        )?;

        // REVIEW; investigate different nodeids with export_buf and export
        // had to change 1.7 to 1.8 to pass the test
        assert_eq!(
            a,
            r##"<p>
hi <sup>
    <a id="fnr.1" href="#fn.1" class="footref" role="doc-backlink">1</a>
</sup> cool test <sup>
    <a id="fnr.2" href="#fn.2" class="footref" role="doc-backlink">2</a>
</sup>  <sup>
    <a id="fnr.1.8" href="#fn.1" class="footref" role="doc-backlink">1</a>
</sup> coolest <sup>
    <a id="fnr.3" href="#fn.3" class="footref" role="doc-backlink">3</a>
</sup> again <sup>
    <a id="fnr.3.13" href="#fn.3" class="footref" role="doc-backlink">3</a>
</sup>
</p>
<p>
novel <sup>
    <a id="fnr.4" href="#fn.4" class="footref" role="doc-backlink">4</a>
</sup>
</p>
<h2 id="footnotes">Footnotes</h2>

<div id="footnotes">
    <style>
    .footdef p {
    display:inline;
    }
    </style>
    <div id="text-footnotes">


<div class="footdef">
<sup>
    <a id="fn.1" href= "#fnr.1" role="doc-backlink">1</a>
</sup>
<p>
abcdef
</p>
</div>

<div class="footdef">
<sup>
    <a id="fn.2" href= "#fnr.2" role="doc-backlink">2</a>
</sup>
<p>
words babby
</p>
</div>

<div class="footdef">
<sup>
    <a id="fn.3" href= "#fnr.3" role="doc-backlink">3</a>
</sup>
<p>
hi
</p>
</div>

<div class="footdef">
<sup>
    <a id="fn.4" href= "#fnr.4" role="doc-backlink">4</a>
</sup>
coolio</div>
  </div>
</div>"##
        );
        Ok(())
    }

    #[test]
    fn esoteric_footnotes() -> Result {
        let a = Html::export(
            r"
And anonymous ones [fn::mysterious]

what [fn::]

bad [fn:]
",
        )?;

        assert_eq!(
            a,
            r##"<p>
And anonymous ones <sup>
    <a id="fnr.1" href="#fn.1" class="footref" role="doc-backlink">1</a>
</sup>
</p>
<p>
what <sup>
    <a id="fnr.2" href="#fn.2" class="footref" role="doc-backlink">2</a>
</sup>
</p>
<p>
bad [fn:]
</p>

<div id="footnotes">
    <style>
    .footdef p {
    display:inline;
    }
    </style>
    <h2 class="footnotes">Footnotes</h2>
    <div id="text-footnotes">


<div class="footdef">
<sup>
    <a id="fn.1" href= "#fnr.1" role="doc-backlink">1</a>
</sup>
mysterious</div>

<div class="footdef">
<sup>
    <a id="fn.2" href= "#fnr.2" role="doc-backlink">2</a>
</sup>
</div>
  </div>
</div>"##
        );

        Ok(())
    }
}