use super::*;

#[test]
fn grammar_expands_nested_mirrors_choices_variables_and_normalized_offsets() {
    let (text, snippet) = expand(
        "call($1, ${1:λ${2:x}}, ${3|a\\,b,c|}, ${UNKNOWN:${TM_LINE_NUMBER}})\r\n$0\\$",
        |name| (name == "TM_LINE_NUMBER").then(|| "4".to_owned()),
    )
    .unwrap();
    assert_eq!(text, "call(λx, λx, a,b, 4)\n$");
    assert_eq!(
        snippet.tabstops,
        vec![
            SnippetTabstop {
                index: 1,
                ranges: vec![5..8, 10..13],
                ancestors: vec![vec![], vec![]]
            },
            SnippetTabstop {
                index: 2,
                ranges: vec![7..8, 12..13],
                ancestors: vec![vec![1], vec![1]]
            },
            SnippetTabstop {
                index: 3,
                ranges: vec![15..18],
                ancestors: vec![vec![]]
            },
            SnippetTabstop {
                index: 0,
                ranges: vec![23..23],
                ancestors: vec![vec![]]
            },
        ]
    );
    let (text, snippet) = expand("call($1, ${2})", |_| None).unwrap();
    assert_eq!(text, "call(, )");
    assert_eq!(
        snippet.tabstops,
        vec![
            SnippetTabstop {
                index: 1,
                ranges: vec![5..5],
                ancestors: vec![vec![]]
            },
            SnippetTabstop {
                index: 2,
                ranges: vec![7..7],
                ancestors: vec![vec![]]
            },
            SnippetTabstop {
                index: 0,
                ranges: vec![8..8],
                ancestors: vec![vec![]]
            },
        ]
    );
    assert_eq!(
        expand("${KNOWN:${1:hidden}}$1", |name| {
            (name == "KNOWN").then(|| "shown".to_owned())
        })
        .unwrap()
        .0,
        "shown"
    );
    let (text, snippet) = expand("call(${CTX})$1", |name| {
        (name == "CTX").then(|| "a\r\nb\rc".to_owned())
    })
    .unwrap();
    assert_eq!(text, "call(a\nb\nc)");
    assert_eq!(snippet.tabstops[0].ranges, [11..11]);
    assert_eq!(
        expand("${1|a\\|b,c|}\\}\\\\", |_| None).unwrap().0,
        "a|b}\\"
    );
    for input in ["${1", "${1:$1}", "${1:a}${1:b}$1", "${1:e}\u{301}"] {
        if input == "${1:a}${1:b}$1" {
            assert_eq!(expand(input, |_| None).unwrap().0, "aaa");
        } else {
            assert_eq!(expand(input, |_| None), Err(Error::Invalid));
        }
    }
    let (text, snippet) = expand("${1}$1", |_| None).unwrap();
    assert!(text.is_empty());
    assert_eq!(
        snippet.tabstops[0],
        SnippetTabstop {
            index: 1,
            ranges: vec![0..0, 0..0],
            ancestors: vec![vec![], vec![]],
        }
    );
    for input in [
        "$UNKNOWN",
        "${TM_FILENAME/(.*)/$1/}",
        "${1/a/b/}",
        "${1:a$0b}",
        "$0$0",
        "${0:arg}",
        "${0:$1}",
    ] {
        assert_eq!(expand(input, |_| None), Err(Error::Unsupported));
    }
    assert_eq!(
        expand(&"$1".repeat(MAX_STOPS + 1), |_| None),
        Err(Error::Limit)
    );
    assert_eq!(
        expand(
            &format!(
                "{}x{}",
                "${1:".repeat(MAX_DEPTH + 1),
                "}".repeat(MAX_DEPTH + 1)
            ),
            |_| None
        ),
        Err(Error::Limit)
    );
}