organic/src/parser/footnote_reference.rs

use nom::branch::alt;
use nom::bytes::complete::tag;
use nom::bytes::complete::tag_no_case;
use nom::character::complete::space0;
use nom::combinator::verify;
use nom::multi::many_till;

use super::parser_context::ContextElement;
use super::Context;
use crate::error::CustomError;
use crate::error::MyError;
use crate::error::Res;
use crate::parser::exiting::ExitClass;
use crate::parser::footnote_definition::label;
use crate::parser::object_parser::standard_set_object;
use crate::parser::parser_context::ExitMatcherNode;
use crate::parser::parser_context::FootnoteReferenceDefinition;
use crate::parser::parser_with_context::parser_with_context;
use crate::parser::util::exit_matcher_parser;
use crate::parser::util::get_consumed;
use crate::parser::FootnoteReference;
use crate::parser::Object;

#[tracing::instrument(ret, level = "debug")]
pub fn footnote_reference<'r, 's>(
    context: Context<'r, 's>,
    input: &'s str,
) -> Res<&'s str, FootnoteReference<'s>> {
    alt((
        parser_with_context!(anonymous_footnote)(context),
        parser_with_context!(footnote_reference_only)(context),
        parser_with_context!(inline_footnote)(context),
    ))(input)
}

#[tracing::instrument(ret, level = "debug")]
fn anonymous_footnote<'r, 's>(
    context: Context<'r, 's>,
    input: &'s str,
) -> Res<&'s str, FootnoteReference<'s>> {
    let (remaining, _) = tag_no_case("[fn::")(input)?;
    let parser_context = context
        .with_additional_node(ContextElement::FootnoteReferenceDefinition(
            FootnoteReferenceDefinition {
                position: remaining,
                depth: 0,
            },
        ))
        .with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
            class: ExitClass::Beta,
            exit_matcher: &footnote_definition_end,
        }));
    // TODO: I could insert FootnoteReferenceDefinition entries in the context after each matched object to reduce the scanning done for counting brackets which should be more efficient.
    let (remaining, (children, _exit_contents)) = verify(
        many_till(
            parser_with_context!(standard_set_object)(&parser_context),
            parser_with_context!(exit_matcher_parser)(&parser_context),
        ),
        |(children, _exit_contents)| !children.is_empty(),
    )(remaining)?;
    let (remaining, _) = tag("]")(remaining)?;

    let (remaining, _) = space0(remaining)?;
    let source = get_consumed(input, remaining);
    Ok((
        remaining,
        FootnoteReference {
            source,
            label: None,
            definition: children,
        },
    ))
}

#[tracing::instrument(ret, level = "debug")]
fn inline_footnote<'r, 's>(
    context: Context<'r, 's>,
    input: &'s str,
) -> Res<&'s str, FootnoteReference<'s>> {
    let (remaining, _) = tag_no_case("[fn:")(input)?;
    let (remaining, label_contents) = label(remaining)?;
    let (remaining, _) = tag(":")(remaining)?;
    let parser_context = context
        .with_additional_node(ContextElement::FootnoteReferenceDefinition(
            FootnoteReferenceDefinition {
                position: remaining,
                depth: 0,
            },
        ))
        .with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
            class: ExitClass::Beta,
            exit_matcher: &footnote_definition_end,
        }));
    // TODO: I could insert FootnoteReferenceDefinition entries in the context after each matched object to reduce the scanning done for counting brackets which should be more efficient.
    let (remaining, (children, _exit_contents)) = verify(
        many_till(
            parser_with_context!(standard_set_object)(&parser_context),
            parser_with_context!(exit_matcher_parser)(&parser_context),
        ),
        |(children, _exit_contents)| !children.is_empty(),
    )(remaining)?;
    let (remaining, _) = tag("]")(remaining)?;

    let (remaining, _) = space0(remaining)?;
    let source = get_consumed(input, remaining);
    Ok((
        remaining,
        FootnoteReference {
            source,
            label: Some(label_contents),
            definition: children,
        },
    ))
}

#[tracing::instrument(ret, level = "debug")]
fn footnote_reference_only<'r, 's>(
    context: Context<'r, 's>,
    input: &'s str,
) -> Res<&'s str, FootnoteReference<'s>> {
    let (remaining, _) = tag_no_case("[fn:")(input)?;
    let (remaining, label_contents) = label(remaining)?;
    let (remaining, _) = tag("]")(remaining)?;
    let (remaining, _) = space0(remaining)?;
    let source = get_consumed(input, remaining);
    Ok((
        remaining,
        FootnoteReference {
            source,
            label: Some(label_contents),
            definition: Vec::with_capacity(0),
        },
    ))
}

#[tracing::instrument(ret, level = "debug")]
fn definition<'s>(input: &'s str) -> Res<&'s str, Vec<Object<'s>>> {
    Ok((input, vec![]))
}

#[tracing::instrument(ret, level = "debug")]
fn footnote_definition_end<'r, 's>(
    context: Context<'r, 's>,
    input: &'s str,
) -> Res<&'s str, &'s str> {
    let context_depth = get_bracket_depth(context)
        .expect("This function should only be called from inside a footnote definition.");
    let text_since_context_entry = get_consumed(context_depth.position, input);
    let mut current_depth = context_depth.depth;
    for c in text_since_context_entry.chars() {
        match c {
            '[' => {
                current_depth += 1;
            }
            ']' if current_depth == 0 => {
                panic!("Exceeded footnote reference definition bracket depth.")
            }
            ']' if current_depth > 0 => {
                current_depth -= 1;
            }
            _ => {}
        }
    }
    if current_depth > 0 {
        // Its impossible for the next character to end the footnote reference definition if we're any amount of brackets deep
        return Err(nom::Err::Error(CustomError::MyError(MyError(
            "NoFootnoteReferenceDefinitionEnd",
        ))));
    }
    tag("]")(input)
}

#[tracing::instrument(ret, level = "debug")]
fn get_bracket_depth<'r, 's>(
    context: Context<'r, 's>,
) -> Option<&'r FootnoteReferenceDefinition<'s>> {
    for node in context.iter() {
        match node.get_data() {
            ContextElement::FootnoteReferenceDefinition(depth) => return Some(depth),
            _ => {}
        }
    }
    None
}