organic/src/context/context.rs

use std::marker::PhantomData;

use nom::combinator::eof;
use nom::IResult;

use super::exiting::ExitClass;
use super::global_settings::GlobalSettings;
use super::list::List;
use super::DynContextMatcher;
use super::RefContext;
use crate::error::CustomError;
use crate::error::MyError;
use crate::error::Res;
use crate::parser::OrgSource;
use crate::types::Keyword;

#[derive(Debug)]
pub(crate) enum ContextElement<'r, 's> {
    /// Stores a parser that indicates that children should exit upon matching an exit matcher.
    ExitMatcherNode(ExitMatcherNode<'r>),

    /// Stores the name of the current element to prevent directly nesting elements of the same type.
    Context(&'r str),

    /// Stores the name of the current object to prevent directly nesting elements of the same type.
    ContextObject(&'r str),

    /// Indicates if elements should consume the whitespace after them.
    ConsumeTrailingWhitespace(bool),

    /// Indicate that we are parsing a paragraph that already has affiliated keywords.
    ///
    /// The value stored is the start of the element after the affiliated keywords. In this way, we can ensure that we do not exit an element immediately after the affiliated keyword had been consumed.
    HasAffiliatedKeyword(HasAffiliatedKeywordInner<'r, 's>),

    /// This is just here to use the 's lifetime until I'm sure we can eliminate it from ContextElement.
    #[allow(dead_code)]
    Placeholder(PhantomData<&'s str>),
}

#[derive(Debug, Clone)]
pub(crate) struct HasAffiliatedKeywordInner<'r, 's> {
    pub(crate) start_after_affiliated_keywords: OrgSource<'s>,
    pub(crate) keywords: &'r Vec<Keyword<'s>>,
}

pub(crate) struct ExitMatcherNode<'r> {
    // TODO: Should this be "&'r DynContextMatcher<'c>" ?
    pub(crate) exit_matcher: &'r DynContextMatcher<'r>,
    pub(crate) class: ExitClass,
}

impl<'r> std::fmt::Debug for ExitMatcherNode<'r> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ExitMatcherNode");
        formatter.field("class", &self.class.to_string());
        formatter.finish()
    }
}

#[derive(Debug)]
pub(crate) struct Context<'g, 'r, 's> {
    global_settings: &'g GlobalSettings<'g, 's>,
    tree: List<'r, &'r ContextElement<'r, 's>>,
}

impl<'g, 'r, 's> Context<'g, 'r, 's> {
    pub(crate) fn new(
        global_settings: &'g GlobalSettings<'g, 's>,
        tree: List<'r, &'r ContextElement<'r, 's>>,
    ) -> Self {
        Self {
            global_settings,
            tree,
        }
    }

    pub(crate) fn with_additional_node(&'r self, new_element: &'r ContextElement<'r, 's>) -> Self {
        let new_tree = self.tree.push(new_element);
        Self::new(self.global_settings, new_tree)
    }

    pub(crate) fn iter(&'r self) -> super::list::Iter<'r, &'r ContextElement<'r, 's>> {
        self.tree.iter()
    }

    fn iter_context(&'r self) -> Iter<'g, 'r, 's> {
        Iter {
            next: self.tree.iter_list(),
            global_settings: self.global_settings,
        }
    }

    pub(crate) fn get_parent(&'r self) -> Option<Self> {
        self.tree.get_parent().map(|parent_tree| Self {
            global_settings: self.global_settings,
            tree: parent_tree.clone(),
        })
    }

    fn get_data(&self) -> &ContextElement<'r, 's> {
        self.tree.get_data()
    }

    pub(crate) fn get_global_settings(&self) -> &'g GlobalSettings<'g, 's> {
        self.global_settings
    }

    pub(crate) fn with_global_settings<'gg>(
        &self,
        new_settings: &'gg GlobalSettings<'gg, 's>,
    ) -> Context<'gg, 'r, 's> {
        Context {
            global_settings: new_settings,
            tree: self.tree.clone(),
        }
    }

    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
    pub(crate) fn check_exit_matcher(
        &'r self,
        i: OrgSource<'s>,
    ) -> IResult<OrgSource<'s>, OrgSource<'s>, CustomError<OrgSource<'s>>> {
        let mut current_class_filter = ExitClass::Gamma;
        for current_node in self.iter_context() {
            let context_element = current_node.get_data();
            match context_element {
                ContextElement::ExitMatcherNode(exit_matcher) => {
                    if exit_matcher.class as u32 <= current_class_filter as u32 {
                        current_class_filter = exit_matcher.class;
                        let local_result = (exit_matcher.exit_matcher)(&current_node, i);
                        if local_result.is_ok() {
                            return local_result;
                        }
                    }
                }
                _ => {}
            };
        }
        // TODO: Make this a specific error instead of just a generic MyError
        return Err(nom::Err::Error(CustomError::MyError(MyError(
            "NoExit".into(),
        ))));
    }

    /// Indicates if elements should consume the whitespace after them.
    ///
    /// Defaults to true.
    pub(crate) fn should_consume_trailing_whitespace(&self) -> bool {
        self._should_consume_trailing_whitespace().unwrap_or(true)
    }

    fn _should_consume_trailing_whitespace(&self) -> Option<bool> {
        for current_node in self.iter() {
            match current_node {
                ContextElement::ConsumeTrailingWhitespace(should) => {
                    return Some(*should);
                }
                _ => {}
            }
        }
        None
    }
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn document_end<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, OrgSource<'s>> {
    eof(input)
}

struct Iter<'g, 'r, 's> {
    global_settings: &'g GlobalSettings<'g, 's>,
    next: super::list::IterList<'r, &'r ContextElement<'r, 's>>,
}

impl<'g, 'r, 's> Iterator for Iter<'g, 'r, 's> {
    type Item = Context<'g, 'r, 's>;

    fn next(&mut self) -> Option<Self::Item> {
        let next_tree = self.next.next();
        let ret =
            next_tree.map(|parent_tree| Context::new(self.global_settings, parent_tree.clone()));
        ret
    }
}

impl<'r, 's> ContextElement<'r, 's> {
    pub(crate) fn document_context() -> Self {
        Self::ExitMatcherNode(ExitMatcherNode {
            exit_matcher: &document_end,
            class: ExitClass::Document,
        })
    }
}