organic/src/parser/parser_context.rs

use std::rc::Rc;

use super::error::CustomError;
use super::error::MyError;
use super::error::Res;
use super::list::List;
use super::list::Node;
use super::Context;
use crate::parser::exiting::ExitClass;
use nom::combinator::eof;
use nom::IResult;

type Matcher = dyn for<'r, 's> Fn(Context<'r, 's>, &'s str) -> Res<&'s str, &'s str>;

#[derive(Debug, Clone)]
pub struct ContextTree<'r, 's> {
    tree: List<ContextElement<'r, 's>>,
}

impl<'r, 's> ContextTree<'r, 's> {
    pub fn new() -> Self {
        ContextTree { tree: List::new() }
    }

    pub fn branch_from(trunk: &Rc<Node<ContextElement<'r, 's>>>) -> Self {
        ContextTree {
            tree: List::branch_from(trunk),
        }
    }

    pub fn ptr_eq<'x, 'y>(&self, other: &ContextTree<'x, 'y>) -> bool {
        self.tree.ptr_eq(&other.tree)
    }

    pub fn with_additional_node(&self, data: ContextElement<'r, 's>) -> ContextTree<'r, 's> {
        let new_list = self.tree.push_front(data);
        ContextTree { tree: new_list }
    }

    pub fn pop_front(&mut self) -> (Option<ContextElement<'r, 's>>, ContextTree<'r, 's>) {
        let (popped_element, remaining) = self.tree.pop_front();
        (popped_element, ContextTree { tree: remaining })
    }

    pub fn iter(&self) -> impl Iterator<Item = &Rc<Node<ContextElement<'r, 's>>>> {
        self.tree.iter()
    }

    pub fn iter_until<'x: 'r>(
        &'r self,
        other: &'x ContextTree<'x, 's>,
    ) -> impl Iterator<Item = &Rc<Node<ContextElement<'r, 's>>>> {
        self.tree.iter_until(&other.tree)
    }

    pub fn into_iter_until<'x: 'r>(
        self,
        other: &'x ContextTree<'x, 's>,
    ) -> impl Iterator<Item = ContextElement<'r, 's>> {
        self.tree.into_iter_until(&other.tree)
    }

    #[tracing::instrument(ret, level = "debug")]
    pub fn check_exit_matcher(
        &'r self,
        i: &'s str,
    ) -> IResult<&'s str, &'s str, CustomError<&'s str>> {
        // Special check for EOF. We don't just make this a document-level exit matcher since the IgnoreParent ChainBehavior could cause early exit matchers to not run.
        let at_end_of_file = eof(i);
        if at_end_of_file.is_ok() {
            return at_end_of_file;
        }

        // let blocked_context =
        //     self.with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
        //         exit_matcher: ChainBehavior::IgnoreParent(Some(&always_fail)),
        //     }));

        let mut current_class_filter = ExitClass::Beta;
        for current_node in self.iter() {
            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_context = ContextTree::branch_from(current_node);
                        let local_result = (exit_matcher.exit_matcher)(&local_context, 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"))));
    }

    pub fn get_document_root(&self) -> Option<&'s str> {
        for current_node in self.iter() {
            let context_element = current_node.get_data();
            match context_element {
                ContextElement::DocumentRoot(body) => {
                    return Some(body);
                }
                _ => {}
            }
        }
        None
    }

    /// Indicates if elements should consume the whitespace after them.
    ///
    /// Defaults to true.
    pub 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() {
            let context_element = current_node.get_data();
            match context_element {
                ContextElement::ConsumeTrailingWhitespace(should) => {
                    return Some(*should);
                }
                _ => {}
            }
        }
        None
    }
}

#[derive(Debug)]
pub enum ContextElement<'r, 's> {
    /// Stores a reference to the entire org-mode document being parsed.
    ///
    /// This is used for look-behind.
    DocumentRoot(&'s str),

    /// Stores a parser that indicates that children should exit upon matching an exit matcher.
    ExitMatcherNode(ExitMatcherNode<'r>),
    Context(&'r str),

    /// Stores the indentation level of the current list item.
    ListItem(usize),

    /// Stores the name of the greater block.
    GreaterBlock(&'s str),

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

pub struct ExitMatcherNode<'r> {
    pub exit_matcher: &'r Matcher,
    pub class: ExitClass,
}

#[derive(Clone)]
pub enum ChainBehavior<'r> {
    AndParent(Option<&'r Matcher>),
    IgnoreParent(Option<&'r Matcher>),
}

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");
        // match self {
        //     ChainBehavior::AndParent(_) => {
        //         formatter = formatter.field("type", &"AndParent");
        //     }
        //     ChainBehavior::IgnoreParent(_) => {
        //         formatter = formatter.field("type", &"IgnoreParent");
        //     }
        // };
        formatter.finish()
    }
}