use itertools::Itertools;
use std::collections::HashMap;

pub struct PestRuleSettings {
    pub visible: bool,
    pub replace: Option<String>,
}

impl Default for PestRuleSettings {
    fn default() -> Self {
        PestRuleSettings {
            visible: true,
            replace: None,
        }
    }
}

pub fn abnf_to_pest(
    data: &Vec<u8>,
    rule_settings: &HashMap<String, PestRuleSettings>,
) -> std::io::Result<String> {
    use abnf::abnf::*;
    use pretty::{BoxDoc, Doc};
    fn format_rule(
        x: Rule,
        rule_settings: &HashMap<String, PestRuleSettings>,
    ) -> Doc<BoxDoc<()>> {
        let rulename = format_rulename(x.name);
        let default = Default::default();
        let setting = rule_settings.get(&rulename).unwrap_or(&default);
        let visible = if setting.visible { "" } else { "_" };
        let contents = match setting.replace {
            None => format_alternation(x.elements),
            Some(ref x) => Doc::text(x.clone()),
        };
        Doc::nil()
            .append(Doc::text(rulename))
            .append(Doc::text(" = "))
            .append(Doc::text(visible))
            .append(Doc::text("{"))
            .append(Doc::space().append(contents).nest(2))
            .append(Doc::space())
            .append(Doc::text("}"))
            .group()
    }
    fn format_rulename(x: String) -> String {
        let x = x.replace("-", "_");
        if x == "if"
            || x == "else"
            || x == "as"
            || x == "let"
            || x == "in"
            || x == "fn"
            // TODO: remove when https://github.com/pest-parser/pest/pull/375 gets into a release
            || x == "whitespace"
        {
            x + "_"
        } else {
            x
        }
    }
    fn format_alternation(x: Alternation) -> Doc<'static, BoxDoc<'static, ()>> {
        Doc::intersperse(
            x.concatenations
                .into_iter()
                .map(|x| format_concatenation(x).nest(2).group()),
            Doc::space().append(Doc::text("| ")),
        )
    }
    fn format_concatenation(
        x: Concatenation,
    ) -> Doc<'static, BoxDoc<'static, ()>> {
        Doc::intersperse(
            x.repetitions.into_iter().map(format_repetition),
            Doc::space().append(Doc::text("~ ")),
        )
    }
    fn format_repetition(x: Repetition) -> Doc<'static, BoxDoc<'static, ()>> {
        format_element(x.element).append(
            x.repeat
                .map(format_repeat)
                .map(Doc::text)
                .unwrap_or(Doc::nil()),
        )
    }
    fn format_repeat(x: Repeat) -> String {
        match (x.min.unwrap_or(0), x.max) {
            (0, None) => "*".into(),
            (1, None) => "+".into(),
            (0, Some(1)) => "?".into(),
            (min, None) => format!("{{{},}}", min),
            (min, Some(max)) if min == max => format!("{{{}}}", min),
            (min, Some(max)) => format!("{{{},{}}}", min, max),
        }
    }
    fn format_element(x: Element) -> Doc<'static, BoxDoc<'static, ()>> {
        use abnf::abnf::Element::*;
        match x {
            Rulename(s) => Doc::text(format_rulename(s)),
            Group(g) => Doc::text("(")
                .append(format_alternation(g.alternation).nest(4).group())
                .append(Doc::text(")")),
            Option(o) => Doc::text("(")
                .append(format_alternation(o.alternation).nest(4).group())
                .append(Doc::text(")?")),
            CharVal(s) => Doc::text(format!(
                "^\"{}\"",
                s.replace("\"", "\\\"").replace("\\", "\\\\")
            )),
            NumVal(r) => Doc::text(format_range(r)),
            ProseVal(_) => unimplemented!(),
        }
    }
    fn format_range(x: Range) -> String {
        use abnf::abnf::Range::*;
        match x {
            Range(x, y) => {
                format!("'{}'..'{}'", format_char(x), format_char(y))
            }
            OneOf(v) => {
                format!("\"{}\"", v.into_iter().map(format_char).join(""))
            }
        }
    }
    fn format_char(x: u64) -> String {
        if x <= (u8::max_value() as u64) {
            let x: u8 = x as u8;
            if x.is_ascii_graphic() {
                let x: char = x as char;
                if x != '"' && x != '\'' && x != '\\' {
                    return x.to_string();
                }
            }
        }
        format!("\\u{{{:02X}}}", x)
    }
    let make_err =
        |e| std::io::Error::new(std::io::ErrorKind::Other, format!("{}", e));

    let rules = rulelist_comp(&data).map_err(make_err)?.1;
    let formatted_rules =
        rules.into_iter().map(|x| format_rule(x, rule_settings));
    let doc: Doc<_> = Doc::intersperse(formatted_rules, Doc::newline());
    Ok(format!("{}", doc.pretty(80)))
}