use nom::branch::alt;
use nom::bytes::complete::tag;
use nom::bytes::complete::tag_no_case;
use nom::character::complete::anychar;
use nom::character::complete::space0;
use nom::combinator::opt;
use nom::combinator::recognize;
use nom::combinator::verify;
use nom::multi::many1;
use nom::multi::many_till;
use nom::multi::separated_list1;
use nom::sequence::tuple;

use super::org_source::OrgSource;
use super::Context;
use crate::error::CustomError;
use crate::error::Res;
use crate::parser::citation_reference::citation_reference;
use crate::parser::citation_reference::citation_reference_key;
use crate::parser::citation_reference::get_bracket_depth;
use crate::parser::exiting::ExitClass;
use crate::parser::object::Citation;
use crate::parser::object_parser::standard_set_object;
use crate::parser::parser_context::CitationBracket;
use crate::parser::parser_context::ContextElement;
use crate::parser::parser_context::ExitMatcherNode;
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::Object;

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn citation<'r, 's>(
    context: Context<'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Citation<'s>> {
    // TODO: Despite being a standard object, citations cannot exist inside the global prefix/suffix for other citations because citations must contain something that matches @key which is forbidden inside the global prefix/suffix. This TODO is to evaluate if its worth putting in an explicit check for this (which can be easily accomplished by checking the output of `get_bracket_depth()`). I suspect its not worth it because I expect, outside of intentionally crafted inputs, this parser will exit immediately inside a citation since it is unlikely to find the "[cite" substring inside a citation global prefix/suffix.
    let (remaining, _) = tag_no_case("[cite")(input)?;
    let (remaining, _) = opt(citestyle)(remaining)?;
    let (remaining, _) = tag(":")(remaining)?;
    let (remaining, _prefix) = opt(parser_with_context!(global_prefix)(context))(remaining)?;
    let (remaining, _references) =
        separated_list1(tag(";"), parser_with_context!(citation_reference)(context))(remaining)?;
    let (remaining, _suffix) = opt(tuple((
        tag(";"),
        parser_with_context!(global_suffix)(context),
    )))(remaining)?;
    let (remaining, _) = tag("]")(remaining)?;
    let (remaining, _) = space0(remaining)?;
    let source = get_consumed(input, remaining);
    Ok((
        remaining,
        Citation {
            source: source.into(),
        },
    ))
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn citestyle<'r, 's>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
    let (remaining, _) = tuple((tag("/"), style))(input)?;
    let (remaining, _) = opt(tuple((tag("/"), variant)))(remaining)?;
    let source = get_consumed(input, remaining);
    Ok((remaining, source))
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn style<'r, 's>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
    recognize(many1(verify(anychar, |c| {
        c.is_alphanumeric() || "_-".contains(*c)
    })))(input)
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn variant<'r, 's>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
    recognize(many1(verify(anychar, |c| {
        c.is_alphanumeric() || "_-/".contains(*c)
    })))(input)
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn global_prefix<'r, 's>(
    context: Context<'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Vec<Object<'s>>> {
    // TODO: I could insert CitationBracket entries in the context after each matched object to reduce the scanning done for counting brackets which should be more efficient.
    let parser_context = context
        .with_additional_node(ContextElement::CitationBracket(CitationBracket {
            position: input,
            depth: 0,
        }))
        .with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
            class: ExitClass::Gamma,
            exit_matcher: &global_prefix_end,
        }));
    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(),
    )(input)?;
    let (remaining, _) = tag(";")(remaining)?;
    Ok((remaining, children))
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn global_prefix_end<'r, 's>(
    context: Context<'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, OrgSource<'s>> {
    let context_depth = get_bracket_depth(context)
        .expect("This function should only be called from inside a citation.");
    let text_since_context_entry = get_consumed(context_depth.position, input);
    let mut current_depth = context_depth.depth;
    for c in Into::<&str>::into(text_since_context_entry).chars() {
        match c {
            '[' => {
                current_depth += 1;
            }
            ']' if current_depth == 0 => {
                panic!("Exceeded citation global prefix bracket depth.")
            }
            ']' if current_depth > 0 => {
                current_depth -= 1;
            }
            _ => {}
        }
    }
    if current_depth == 0 {
        let close_bracket = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("]")(input);
        if close_bracket.is_ok() {
            return close_bracket;
        }
    }
    alt((
        tag(";"),
        recognize(parser_with_context!(citation_reference_key)(context)),
    ))(input)
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn global_suffix<'r, 's>(
    context: Context<'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Vec<Object<'s>>> {
    // TODO: I could insert CitationBracket entries in the context after each matched object to reduce the scanning done for counting brackets which should be more efficient.
    let parser_context = context
        .with_additional_node(ContextElement::CitationBracket(CitationBracket {
            position: input,
            depth: 0,
        }))
        .with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
            class: ExitClass::Gamma,
            exit_matcher: &global_suffix_end,
        }));
    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(),
    )(input)?;
    Ok((remaining, children))
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn global_suffix_end<'r, 's>(
    context: Context<'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, OrgSource<'s>> {
    let context_depth = get_bracket_depth(context)
        .expect("This function should only be called from inside a citation.");
    let text_since_context_entry = get_consumed(context_depth.position, input);
    let mut current_depth = context_depth.depth;
    for c in Into::<&str>::into(text_since_context_entry).chars() {
        match c {
            '[' => {
                current_depth += 1;
            }
            ']' if current_depth == 0 => {
                panic!("Exceeded citation global suffix bracket depth.")
            }
            ']' if current_depth > 0 => {
                current_depth -= 1;
            }
            _ => {}
        }
    }
    if current_depth == 0 {
        let close_bracket = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("]")(input);
        if close_bracket.is_ok() {
            return close_bracket;
        }
    }
    alt((
        tag(";"),
        recognize(parser_with_context!(citation_reference_key)(context)),
    ))(input)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parser::element_parser::element;
    use crate::parser::parser_context::ContextTree;
    use crate::parser::parser_with_context::parser_with_context;
    use crate::parser::source::Source;

    #[test]
    fn citation_simple() {
        let input = OrgSource::new("[cite:@foo]");
        let initial_context: ContextTree<'_, '_> = ContextTree::new();
        let paragraph_matcher = parser_with_context!(element(true))(&initial_context);
        let (remaining, first_paragraph) = paragraph_matcher(input).expect("Parse first paragraph");
        let first_paragraph = match first_paragraph {
            crate::parser::Element::Paragraph(paragraph) => paragraph,
            _ => panic!("Should be a paragraph!"),
        };
        assert_eq!(Into::<&str>::into(remaining), "");
        assert_eq!(first_paragraph.get_source(), "[cite:@foo]");
        assert_eq!(first_paragraph.children.len(), 1);
        assert_eq!(
            first_paragraph
                .children
                .get(0)
                .expect("Len already asserted to be 1"),
            &Object::Citation(Citation {
                source: "[cite:@foo]"
            })
        );
    }
}