use std::{collections::HashMap, rc::Rc, str::MatchIndices};

use std::{collections::HashMap, rc::Rc};

use chumsky::Parser;

    // TODO allow these to refer to amounts
    // 0 [x] static amounts
    // 1 [ ] input variable amounts (cost pre-declared X and Y, overlay count O)
    // 2 [ ] arbitrary amounts ("number of Horrowshow magister/aides")

    fn compact(notation: String) -> Vec<Mana> {
        let mut mana = HashMap::new();
        let mut start_index = 0;
        let mut end_index = 0;
        let notation = notation.to_ascii_lowercase();
        while start_index < notation.len() {
            // inc end_index
            end_index += 1;
            let slice = &notation[start_index..end_index];
            match slice {
                "m" => {
                    *mana.entry(Some(Color::Mundane)).or_insert(0) += 1;
                    start_index = end_index;
                }
                "d" => {
                    *mana.entry(Some(Color::Divine)).or_insert(0) += 1;
                    start_index = end_index;
                }
                "r" => {
                    *mana.entry(Some(Color::Revelation)).or_insert(0) += 1;
                    start_index = end_index;

    fn compact_parser<'a>() -> impl Parser<
        'a,
        &'a str,
        Vec<(Option<Color>, usize)>,
        chumsky::extra::Err<chumsky::prelude::Rich<'a, char>>,
    > {
        use chumsky::prelude::*;
        choice((
            just('m')
                .repeated()
                .at_least(1)
                .collect::<String>()
                .map(|s: String| (Some(Color::Mundane), s.len())),
            just('d')
                .repeated()
                .at_least(1)
                .collect::<String>()
                .map(|s: String| (Some(Color::Divine), s.len())),
            just('r')
                .repeated()
                .at_least(1)
                .collect::<String>()
                .map(|s: String| (Some(Color::Revelation), s.len())),
            just('a')
                .repeated()
                .at_least(1)
                .collect::<String>()
                .map(|s: String| (Some(Color::Grace), s.len())),
            just('g')
                .repeated()
                .at_least(1)
                .collect::<String>()
                .map(|s: String| (Some(Color::Growth), s.len())),
            just('u')
                .repeated()
                .at_least(1)
                .collect::<String>()
                .map(|s: String| (Some(Color::Crusade), s.len())),
            just('s')
                .repeated()
                .at_least(1)
                .collect::<String>()
                .map(|s: String| (Some(Color::Suffering), s.len())),
            text::int(10).try_map(|i: &str, span| {
                i.parse::<usize>()
                    .map(|i| (None, i))
                    .map_err(|e| Rich::custom(span, e))
            }),
        ))
        .repeated()
        .collect()
    }
    fn compact(notation: String) -> Result<Vec<Mana>, String> {
        let notation_input = notation.to_ascii_lowercase();
        let (output, errs) = Self::compact_parser()
            .parse(&notation_input)
            .into_output_errors();
        match output {
            Some(outputs) => {
                let mut mana = HashMap::new();
                for (maybe_color, count) in outputs.into_iter() {
                    *mana.entry(maybe_color).or_insert(0) += count;

                "a" => {
                    *mana.entry(Some(Color::Grace)).or_insert(0) += 1;
                    start_index = end_index;
                }
                "g" => {
                    *mana.entry(Some(Color::Growth)).or_insert(0) += 1;
                    start_index = end_index;
                }
                "u" => {
                    *mana.entry(Some(Color::Crusade)).or_insert(0) += 1;
                    start_index = end_index;
                }
                "s" => {
                    *mana.entry(Some(Color::Suffering)).or_insert(0) += 1;
                    start_index = end_index;
                }
                _ => {
                    while end_index <= notation.len()
                        && notation[start_index..end_index]
                            .chars()
                            .all(|c| c.is_digit(10))
                    {
                        end_index += 1;
                    }
                    // End index is 1 too high, sub 1
                    end_index -= 1;
                    let number: usize = notation[start_index..end_index]
                        .parse()
                        .expect("expected parseable base-10 digit string");
                    *mana.entry(None).or_insert(0) += number;
                    start_index = end_index;
                }

                Ok(mana
                    .into_iter()
                    .map(|(k, v)| {
                        if let Some(color) = k {
                            Mana::Color(v, color)
                        } else {
                            Mana::Any(v)
                        }
                    })
                    .collect())
            }
            None => {
                // Technically incorrect usage (we assume stderr), but w/e, this should
                // be running on desktops/laptops/non-web anyways
                errs.into_iter().for_each(|e| {
                    ariadne::Report::build(ariadne::ReportKind::Error, (), e.span().start)
                        .with_message(e.to_string())
                        .with_label(
                            ariadne::Label::new(e.span().into_range())
                                .with_message(e.reason().to_string())
                                .with_color(ariadne::Color::Red),
                        )
                        .finish()
                        .eprint(ariadne::Source::from(&notation))
                        .unwrap()
                });
                Err(format!("Failed to parse compact mana string: {notation}"))

        mana.into_iter()
            .map(|(k, v)| {
                if let Some(color) = k {
                    Mana::Color(v, color)
                } else {
                    Mana::Any(v)
                }
            })
            .collect()

ariadne = "0.4.0"
chumsky = { version = "~1.0.0-alpha.6", features = [] }