use std::borrow::Cow;
use std::collections::HashSet;
use std::error::Error;

use lazy_static::lazy_static;
use nom::branch::alt;
use nom::bytes::complete::take_while;
use nom::{bytes::complete::tag, combinator::map, IResult};
use regex::Regex;

#[derive(Debug)]
enum Token<'a> {
    OpenCloze(u16),
    Text(&'a str),
    CloseCloze,
}

// todo: error handling
fn tokenize(mut text: &str) -> impl Iterator<Item = Token> {
    fn open_cloze(text: &str) -> IResult<&str, Token> {
        // opening brackets and 'c'
        let (text, _opening_brackets_and_c) = tag("{{c")(text)?;
        // following number
        let (text, digits) = take_while(|c: char| c.is_ascii_digit())(text)?;
        let digits: u16 = match digits.parse() {
            Ok(digits) => digits,
            Err(_) => {
                // not a valid number; fail to recognize
                return Err(nom::Err::Error(nom::error::make_error(
                    text,
                    nom::error::ErrorKind::Digit,
                )));
            }
        };
        // ::
        let (text, _colons) = tag("::")(text)?;
        Ok((text, Token::OpenCloze(digits)))
    }

    fn close_cloze(text: &str) -> IResult<&str, Token> {
        map(tag("}}"), |_| Token::CloseCloze)(text)
    }

    /// Match a run of text until an open/close marker is encountered.
    fn normal_text(text: &str) -> IResult<&str, Token> {
        if text.is_empty() {
            return Err(nom::Err::Error(nom::error::make_error(
                text,
                nom::error::ErrorKind::Eof,
            )));
        }
        let mut index = 0;
        let mut other_token = alt((open_cloze, close_cloze));
        while other_token(&text[index..]).is_err() && index < text.len() {
            index += 1;
        }
        Ok((&text[index..], Token::Text(&text[0..index])))
    }

    std::iter::from_fn(move || {
        if text.is_empty() {
            None
        } else {
            let (remaining_text, token) =
                alt((open_cloze, close_cloze, normal_text))(text).unwrap();
            text = remaining_text;
            Some(token)
        }
    })
}

#[derive(Debug)]
enum TextOrCloze<'a> {
    Text(&'a str),
    Cloze(ExtractedCloze<'a>),
}

#[derive(Debug)]
struct ExtractedCloze<'a> {
    ordinal: u16,
    nodes: Vec<TextOrCloze<'a>>,
    hint: Option<&'a str>,
}

fn parse_text_with_clozes(text: &str) -> Vec<TextOrCloze<'_>> {
    let mut open_clozes: Vec<ExtractedCloze> = vec![];
    let mut output = vec![];
    for token in tokenize(text) {
        match token {
            Token::OpenCloze(ordinal) => open_clozes.push(ExtractedCloze {
                ordinal,
                nodes: Vec::with_capacity(1), // common case
                hint: None,
            }),
            Token::Text(mut text) => {
                if let Some(cloze) = open_clozes.last_mut() {
                    // extract hint if found
                    if let Some((head, tail)) = text.split_once("::") {
                        text = head;
                        cloze.hint = Some(tail);
                    }
                    cloze.nodes.push(TextOrCloze::Text(text));
                } else {
                    output.push(TextOrCloze::Text(text));
                }
            }
            Token::CloseCloze => {
                // take the currently active cloze
                if let Some(cloze) = open_clozes.pop() {
                    let target = if let Some(outer_cloze) = open_clozes.last_mut() {
                        // and place it into the cloze layer above
                        &mut outer_cloze.nodes
                    } else {
                        // or the top level if no other clozes active
                        &mut output
                    };
                    target.push(TextOrCloze::Cloze(cloze));
                } else {
                    // closing marker outside of any clozes
                    output.push(TextOrCloze::Text("}}"))
                }
            }
        }
    }
    output
}

impl ExtractedCloze<'_> {
    /// Return the cloze's hint, or "..." if none was provided.
    fn hint(&self) -> &str {
        self.hint.unwrap_or("...")
    }

    fn clozed_text(&self) -> Cow<str> {
        // happy efficient path?
        if self.nodes.len() == 1 {
            if let TextOrCloze::Text(text) = self.nodes.last().unwrap() {
                return (*text).into();
            }
        }

        let mut buf = String::new();
        for node in &self.nodes {
            match node {
                TextOrCloze::Text(text) => buf.push_str(text),
                TextOrCloze::Cloze(cloze) => buf.push_str(&cloze.clozed_text()),
            }
        }

        buf.into()
    }
}

pub fn cloze_numbers_in_string(html: &str) -> HashSet<u16> {
    let mut set = HashSet::with_capacity(4);
    add_cloze_numbers_in_string(html, &mut set);
    set
}

#[allow(clippy::implicit_hasher)]
pub fn add_cloze_numbers_in_string(html: &str, set: &mut HashSet<u16>) {
    add_cloze_numbers_in_text_with_clozes(&parse_text_with_clozes(html), set)
}

fn add_cloze_numbers_in_text_with_clozes(nodes: &[TextOrCloze], set: &mut HashSet<u16>) {
    for node in nodes {
        if let TextOrCloze::Cloze(cloze) = node {
            set.insert(cloze.ordinal);
            add_cloze_numbers_in_text_with_clozes(&cloze.nodes, set);
        }
    }
}

pub fn reveal_cloze_text_only(text: &str, cloze_ord: u16, question: bool) -> String {
    let mut output = Vec::new();
    for node in &parse_text_with_clozes(text) {
        reveal_cloze_text_in_nodes(node, cloze_ord, question, &mut output);
    }
    output.join(", ")
}

fn reveal_cloze_text_in_nodes(
    node: &TextOrCloze,
    cloze_ord: u16,
    question: bool,
    output: &mut Vec<String>,
) {
    if let TextOrCloze::Cloze(cloze) = node {
        if cloze.ordinal == cloze_ord {
            if question {
                output.push(cloze.hint().into())
            } else {
                output.push(cloze.clozed_text().into())
            }
        }
        for node in &cloze.nodes {
            reveal_cloze_text_in_nodes(&node, cloze_ord, question, output);
        }
    }
}

pub fn reveal_cloze_text(text: &str, cloze_ord: u16, question: bool) -> String {
    let mut buf = String::new();
    let mut active_cloze_found_in_text = false;
    for node in &parse_text_with_clozes(text) {
        match node {
            // top-level text is indiscriminately added
            TextOrCloze::Text(text) => buf.push_str(text),
            TextOrCloze::Cloze(cloze) => reveal_cloze(
                cloze,
                cloze_ord,
                question,
                &mut active_cloze_found_in_text,
                &mut buf,
            ),
        }
    }
    if active_cloze_found_in_text {
        buf
    } else {
        String::new()
    }
}

fn reveal_cloze(
    cloze: &ExtractedCloze,
    cloze_ord: u16,
    question: bool,
    active_cloze_found_in_text: &mut bool,
    buf: &mut String,
) {
    let active = cloze.ordinal == cloze_ord;
    *active_cloze_found_in_text |= active;
    match (question, active) {
        (true, true) => {
            // question side with active cloze; all inner content is elided
            // (but will probably need to recurse to gather the text to include in data-cloze)
            buf.push_str("<div class=active>");
            buf.push_str(&format!("[{}]", cloze.hint()));
            buf.push_str("</div>");
            return;
        }
        (false, true) => {
            // answer side with active cloze; content from inner clozes is included
            buf.push_str("<div class=active>");
            buf.push_str(&cloze.clozed_text());
            buf.push_str("</>");
        }
        (true, false) => {
            // question side with inactive cloze; text shown normally, but child clozes may be elided
            buf.push_str("<div class=inactive>");
            for node in &cloze.nodes {
                match node {
                    TextOrCloze::Text(text) => buf.push_str(text),
                    TextOrCloze::Cloze(cloze) => {
                        reveal_cloze(cloze, cloze_ord, question, active_cloze_found_in_text, buf)
                    }
                }
            }
            buf.push_str("</div>")
        }
        (false, false) => {
            // answer side with inactive cloze; inner clozes may be active
            buf.push_str("<div class=inactive>");
            for node in &cloze.nodes {
                match node {
                    TextOrCloze::Text(text) => buf.push_str(text),
                    TextOrCloze::Cloze(cloze) => {
                        reveal_cloze(cloze, cloze_ord, question, active_cloze_found_in_text, buf)
                    }
                }
            }
            buf.push_str("</div>");
        }
    }
}

fn contains_cloze(text: &str) -> bool {
    parse_text_with_clozes(text)
        .iter()
        .any(|node| matches!(node, TextOrCloze::Cloze(_)))
}

pub(crate) trait CowMapping<'a, B: ?Sized + 'a + ToOwned> {
    /// Returns [self]
    /// - unchanged, if the given function returns [Cow::Borrowed]
    /// - with the new value, if the given function returns [Cow::Owned]
    fn map_cow(self, f: impl FnOnce(&B) -> Cow<B>) -> Self;
    fn get_owned(self) -> Option<B::Owned>;
}

impl<'a, B: ?Sized + 'a + ToOwned> CowMapping<'a, B> for Cow<'a, B> {
    fn map_cow(self, f: impl FnOnce(&B) -> Cow<B>) -> Self {
        if let Cow::Owned(o) = f(&self) {
            Cow::Owned(o)
        } else {
            self
        }
    }

    fn get_owned(self) -> Option<B::Owned> {
        match self {
            Cow::Borrowed(_) => None,
            Cow::Owned(s) => Some(s),
        }
    }
}

pub fn decode_entities(html: &str) -> Cow<str> {
    if html.contains('&') {
        match htmlescape::decode_html(html) {
            Ok(text) => text.replace('\u{a0}', " ").into(),
            Err(_) => html.into(),
        }
    } else {
        // nothing to do
        html.into()
    }
}

lazy_static! {
static ref HTML: Regex = Regex::new(concat!(
    "(?si)",
    // wrapped text
    r"(<!--.*?-->)|(<style.*?>.*?</style>)|(<script.*?>.*?</script>)",
    // html tags
    r"|(<.*?>)",
))
.unwrap();
}
pub fn strip_html(html: &str) -> Cow<str> {
    strip_html_preserving_entities(html).map_cow(decode_entities)
}

pub fn strip_html_preserving_entities(html: &str) -> Cow<str> {
    HTML.replace_all(html, "")
}

fn main() -> Result<(), Box<dyn Error>> {
    dbg!(parse_text_with_clozes("foo {{c1::bar {{c2::baz}}}}"));
    dbg!(parse_text_with_clozes(
        "foo {{{c1::bar {{c2::baz}}::qux}} hello ::"
    ));
    dbg!(parse_text_with_clozes("foo }} :: {{c1::bar}} baz"));

    assert_eq!(
        cloze_numbers_in_string("test"),
        vec![].into_iter().collect::<HashSet<u16>>()
    );
    assert_eq!(
        cloze_numbers_in_string("{{c2::te}}{{c1::s}}t{{"),
        vec![1, 2].into_iter().collect::<HashSet<u16>>()
    );
    // new addition
    assert_eq!(
        cloze_numbers_in_string("foo {{c1::bar {{c2::baz}}}}"),
        vec![1, 2].into_iter().collect::<HashSet<u16>>()
    );

    // cloze only
    assert_eq!(reveal_cloze_text_only("foo", 1, true), "");
    assert_eq!(reveal_cloze_text_only("foo {{c1::bar}}", 1, true), "...");
    assert_eq!(
        reveal_cloze_text_only("foo {{c1::bar::baz}}", 1, true),
        "baz"
    );
    assert_eq!(reveal_cloze_text_only("foo {{c1::bar}}", 1, false), "bar");
    assert_eq!(reveal_cloze_text_only("foo {{c1::bar}}", 2, false), "");
    assert_eq!(
        reveal_cloze_text_only("{{c1::foo}} {{c1::bar}}", 1, false),
        "foo, bar"
    );
    // new additions
    assert_eq!(
        reveal_cloze_text_only("foo {{c1::bar {{c2::baz}}}}", 1, true),
        "..."
    );
    assert_eq!(
        reveal_cloze_text_only("foo {{c1::bar {{c2::baz}}}}", 1, false),
        "bar baz"
    );
    assert_eq!(
        reveal_cloze_text_only("foo {{c1::bar {{c2::baz}}}}", 2, true),
        "..."
    );
    assert_eq!(
        reveal_cloze_text_only("foo {{c1::bar {{c2::baz}}}}", 2, false),
        "baz"
    );
    assert_eq!(
        reveal_cloze_text_only("foo {{c1::bar {{c1::baz::hint2}}::hint}}", 1, true),
        "hint, hint2"
    );
    assert_eq!(
        reveal_cloze_text_only("foo {{c1::bar {{c2::baz::hint2}}::hint}}", 2, true),
        "hint2"
    );
    assert_eq!(
        reveal_cloze_text_only("foo {{c1::bar {{c1::baz}}}}", 1, false),
        "bar baz, baz"
    );

    assert_eq!(
        strip_html(reveal_cloze_text("foo {{c1::bar {{c2::baz}}}}", 1, true).as_ref()),
        "foo [...]"
    );
    assert_eq!(
        strip_html(reveal_cloze_text("foo {{c1::bar {{c2::baz}}}}", 1, false).as_ref()),
        "foo bar baz"
    );
    assert_eq!(
        strip_html(reveal_cloze_text("foo {{c1::bar {{c2::baz}}::qux}}", 2, true).as_ref()),
        "foo bar [...]"
    );
    assert_eq!(
        strip_html(reveal_cloze_text("foo {{c1::bar {{c2::baz}}::qux}}", 2, false).as_ref()),
        "foo bar baz"
    );
    assert_eq!(
        strip_html(reveal_cloze_text("foo {{c1::bar {{c2::baz}}::qux}}", 1, true).as_ref()),
        "foo [qux]"
    );
    assert_eq!(
        strip_html(reveal_cloze_text("foo {{c1::bar {{c2::baz}}::qux}}", 1, false).as_ref()),
        "foo bar baz"
    );

    Ok(())
}