#![allow(clippy::disallowed_names)]

const ANSWERS: &[(&str, &str)] = &[
    ("foo_isset", "foo"),
    ("foo_isset_alternate_bar_isset", "bar"),
    ("foo_isset_alternate_bar_isset_alternate_baz_isset", "baz"),
    ("foo_isset_alternate_bar_isset_alternate_baz_notset", ""),
    ("foo_isset_alternate_bar_isset_default_baz_isset", "bar"),
    ("foo_isset_alternate_bar_isset_default_baz_notset", "bar"),
    ("foo_isset_alternate_bar_notset", ""),
    ("foo_isset_alternate_bar_notset_alternate_baz_isset", ""),
    ("foo_isset_alternate_bar_notset_alternate_baz_notset", ""),
    ("foo_isset_alternate_bar_notset_default_baz_isset", "baz"),
    ("foo_isset_alternate_bar_notset_default_baz_notset", ""),
    ("foo_isset_default_bar_isset", "foo"),
    ("foo_isset_default_bar_isset_alternate_baz_isset", "foo"),
    ("foo_isset_default_bar_isset_alternate_baz_notset", "foo"),
    ("foo_isset_default_bar_isset_default_baz_isset", "foo"),
    ("foo_isset_default_bar_isset_default_baz_notset", "foo"),
    ("foo_isset_default_bar_notset", "foo"),
    ("foo_isset_default_bar_notset_alternate_baz_isset", "foo"),
    ("foo_isset_default_bar_notset_alternate_baz_notset", "foo"),
    ("foo_isset_default_bar_notset_default_baz_isset", "foo"),
    ("foo_isset_default_bar_notset_default_baz_notset", "foo"),
    ("foo_notset", ""),
    ("foo_notset_alternate_bar_isset", ""),
    ("foo_notset_alternate_bar_isset_alternate_baz_isset", ""),
    ("foo_notset_alternate_bar_isset_alternate_baz_notset", ""),
    ("foo_notset_alternate_bar_isset_default_baz_isset", ""),
    ("foo_notset_alternate_bar_isset_default_baz_notset", ""),
    ("foo_notset_alternate_bar_notset", ""),
    ("foo_notset_alternate_bar_notset_alternate_baz_isset", ""),
    ("foo_notset_alternate_bar_notset_alternate_baz_notset", ""),
    ("foo_notset_alternate_bar_notset_default_baz_isset", ""),
    ("foo_notset_alternate_bar_notset_default_baz_notset", ""),
    ("foo_notset_default_bar_isset", "bar"),
    ("foo_notset_default_bar_isset_alternate_baz_isset", "baz"),
    ("foo_notset_default_bar_isset_alternate_baz_notset", ""),
    ("foo_notset_default_bar_isset_default_baz_isset", "bar"),
    ("foo_notset_default_bar_isset_default_baz_notset", "bar"),
    ("foo_notset_default_bar_notset", ""),
    ("foo_notset_default_bar_notset_alternate_baz_isset", ""),
    ("foo_notset_default_bar_notset_alternate_baz_notset", ""),
    ("foo_notset_default_bar_notset_default_baz_isset", "baz"),
    ("foo_notset_default_bar_notset_default_baz_notset", ""),
];

#[derive(Clone, Copy, Debug)]
enum Operator {
    DefaultValue,
    AlternateValue,
}

impl Operator {
    fn as_str(self) -> &'static str {
        match self {
            Self::DefaultValue => "-",
            Self::AlternateValue => "+",
        }
    }
}

const OPS: &[Operator] = &[Operator::DefaultValue, Operator::AlternateValue];

fn expect(test_name: &str) -> &str {
    for (tn, e) in ANSWERS.iter() {
        if *tn == test_name {
            return e;
        }
    }
    ""
}

fn generate_test_case1(foo: Option<String>) {
    let mut test_name = String::new();
    if foo.is_some() {
        test_name += "foo_isset";
    } else {
        test_name += "foo_notset";
    };

    println!("\n#[test]");
    println!("fn {test_name}_1() {{");

    println!("    let env: HashMap<&str, &str> = HashMap::from([");
    if let Some(foo) = foo {
        println!("        (\"FOO\", {foo:?}),");
    }
    println!("    ]);");

    let expect = expect(&test_name);
    let mut assertion = format!("assert_eq!({expect:?}");
    assertion += ", expand(&env, \"${FOO}\").unwrap())";
    println!("    {assertion}");
    println!("}}");
}

fn generate_test_case3(foo: Option<String>, op1: Operator, bar: Option<String>) {
    let mut test_name = String::new();
    if foo.is_some() {
        test_name += "foo_isset_";
    } else {
        test_name += "foo_notset_";
    };
    test_name += match op1 {
        Operator::DefaultValue => "default",
        Operator::AlternateValue => "alternate",
    };
    if bar.is_some() {
        test_name += "_bar_isset";
    } else {
        test_name += "_bar_notset";
    };

    println!("\n#[test]");
    println!("fn {test_name}_2() {{");

    println!("    let env: HashMap<&str, &str> = HashMap::from([");
    if let Some(foo) = foo {
        println!("        (\"FOO\", {foo:?}),");
    }
    if let Some(bar) = bar {
        println!("        (\"BAR\", {bar:?}),");
    }
    println!("    ]);");
    let expect = expect(&test_name);
    let mut assertion = format!("assert_eq!({expect:?}");
    assertion += ", expand(&env, \"${FOO:";
    assertion += op1.as_str();
    assertion += "${BAR}}\").unwrap());";
    println!("    {assertion}");
    println!("}}");
}

fn generate_test_case5(
    foo: Option<String>,
    op1: Operator,
    bar: Option<String>,
    op2: Operator,
    baz: Option<String>,
) {
    let mut test_name = String::new();
    if foo.is_some() {
        test_name += "foo_isset_";
    } else {
        test_name += "foo_notset_";
    };
    test_name += match op1 {
        Operator::DefaultValue => "default",
        Operator::AlternateValue => "alternate",
    };
    if bar.is_some() {
        test_name += "_bar_isset_";
    } else {
        test_name += "_bar_notset_";
    };
    test_name += match op2 {
        Operator::DefaultValue => "default",
        Operator::AlternateValue => "alternate",
    };
    if baz.is_some() {
        test_name += "_baz_isset";
    } else {
        test_name += "_baz_notset";
    };

    println!("\n#[test]");
    println!("fn {test_name}_3() {{");

    println!("    let env: HashMap<&str, &str> = HashMap::from([");
    if let Some(foo) = foo {
        println!("        (\"FOO\", {foo:?}),");
    }
    if let Some(bar) = bar {
        println!("        (\"BAR\", {bar:?}),");
    }
    if let Some(baz) = baz {
        println!("        (\"BAZ\", {baz:?}),");
    }
    println!("    ]);");
    let expect = expect(&test_name);
    let mut assertion = format!("assert_eq!({expect:?}");
    assertion += ", expand(&env, \"${FOO:";
    assertion += op1.as_str();
    assertion += "${BAR:";
    assertion += op2.as_str();
    assertion += "${BAZ}}}\").unwrap());";
    println!("    {assertion}");
    println!("}}");
}

fn foo_bar_baz(idx: usize) -> (Option<String>, Option<String>, Option<String>) {
    let foo = if idx & 1 != 0 {
        Some("foo".to_string())
    } else {
        None
    };
    let bar = if idx & 2 != 0 {
        Some("bar".to_string())
    } else {
        None
    };
    let baz = if idx & 4 != 0 {
        Some("baz".to_string())
    } else {
        None
    };
    (foo, bar, baz)
}

fn main() {
    println!("// AUTO-GENERATED FILE:  DO NOT EDIT MANUALLY (or with sed)");
    println!("// regenerate with:  cargo run --example tests > tests/shvar.rs && cargo fmt");
    println!("use std::collections::HashMap;");
    println!("use shvar::expand;");

    for idx in 0..2 {
        let (foo, _, _) = foo_bar_baz(idx);
        generate_test_case1(foo);
    }

    for idx in 0..4 {
        for op1 in OPS {
            let (foo, bar, _) = foo_bar_baz(idx);
            generate_test_case3(foo, *op1, bar);
        }
    }

    for idx in 0..8 {
        for op1 in OPS {
            for op2 in OPS {
                let (foo, bar, baz) = foo_bar_baz(idx);
                generate_test_case5(foo, *op1, bar, *op2, baz);
            }
        }
    }
}