use std::path::Path;

#[test]
fn consuming_the_entire_prefix_does_not_lead_to_a_single_dot() -> crate::Result {
    let spec = normalized_spec("..", "a", "")?;
    assert_eq!(
        spec.path(),
        ".",
        "the top-level of the worktree can take the special value '.' to mean 'everything'"
    );
    assert!(
        spec.is_nil(),
        "single is for the worktree top-level, and since it wouldn't match anything we make it nil so it does"
    );
    assert_eq!(spec.prefix_directory(), "", "there is no prefix left");
    Ok(())
}

#[test]
fn removes_relative_path_components() -> crate::Result {
    for (input_path, expected_path, expected_prefix) in [
        ("..", "a", ""),
        ("c", "a/b/c", "a/b"),
        ("../c", "a/c", "a"),
        ("../b/c", "a/b/c", "a"), // this is a feature - prefix components once consumed by .. are lost. Important as paths can contain globs
        ("../*c/d", "a/*c/d", "a"),
        ("../../c/d", "c/d", ""),
        ("../../c/d/", "c/d", ""),
        ("./c", "a/b/c", "a/b"),
        ("../../c", "c", ""),
        ("../..", ".", ""),
        ("../././c", "a/c", "a"),
        ("././/./c", "a/b/c", "a/b"),
        ("././/./c/", "a/b/c", "a/b"),
        ("././/./../c/d/", "a/c/d", "a"),
    ] {
        let spec = normalized_spec(input_path, "a/b", "")?;
        assert_eq!(spec.path(), expected_path);
        assert_eq!(
            spec.prefix_directory(),
            expected_prefix,
            "{input_path} -> {expected_path}"
        );
    }
    Ok(())
}

#[test]
fn single_dot_is_special_and_directory_is_implied_without_trailing_slash() -> crate::Result {
    for (input_path, expected) in [(".", "."), ("./", ".")] {
        let spec = normalized_spec(input_path, "", "/repo")?;
        assert_eq!(spec.path(), expected);
        assert!(spec.is_nil(), "such a spec has to match everything");
        assert_eq!(spec.prefix_directory(), "");
    }
    Ok(())
}

#[test]
fn absolute_path_made_relative() -> crate::Result {
    for (input_path, expected, prefix_dir) in [
        ("/repo/a", "a", ""),
        ("/repo/a/..//.///b", "b", ""),
        ("/repo/a/", "a", "a"),
        ("/repo/*/", "*", "*"),
        ("/repo/a/b", "a/b", "a"),
        ("/repo/*/b", "*/b", "*"), // we assume literal paths if specs are absolute
        ("/repo/a/*/", "a/*", "a/*"),
        ("/repo/a/b/", "a/b", "a/b"),
        ("/repo/a/b/*", "a/b/*", "a/b"),
        ("/repo/a/b/c/..", "a/b", "a"),
    ] {
        let spec = normalized_spec(input_path, "", "/repo")?;
        assert_eq!(spec.path(), expected);
        assert_eq!(spec.prefix_directory(), prefix_dir, "{input_path}");
    }
    Ok(())
}

#[test]
fn relative_top_patterns_ignore_the_prefix() -> crate::Result {
    let spec = normalized_spec(":(top)c", "a/b", "")?;
    assert_eq!(spec.path(), "c");
    assert_eq!(spec.prefix_directory(), "");
    Ok(())
}

#[test]
fn absolute_top_patterns_ignore_the_prefix_but_are_made_relative() -> crate::Result {
    let spec = normalized_spec(":(top)/a/b", "prefix-ignored", "/a")?;
    assert_eq!(spec.path(), "b");
    assert_eq!(spec.prefix_directory(), "");
    Ok(())
}

#[test]
fn relative_path_breaks_out_of_working_tree() {
    let err = normalized_spec("../a", "", "").unwrap_err();
    assert_eq!(err.to_string(), "The path '../a' leaves the repository");
    let err = normalized_spec("../../b", "a", "").unwrap_err();
    assert_eq!(
        err.to_string(),
        format!(
            "The path '{}' leaves the repository",
            if cfg!(windows) { r"a\../../b" } else { "a/../../b" }
        )
    );
}

#[test]
fn absolute_path_breaks_out_of_working_tree() {
    let err = normalized_spec("/path/to/repo/..///./a", "", "/path/to/repo").unwrap_err();
    assert_eq!(err.to_string(), "The path '..///./a' leaves the repository");
    let err = normalized_spec("/path/to/repo/../../../dev", "", "/path/to/repo").unwrap_err();
    assert_eq!(err.to_string(), "The path '../../../dev' leaves the repository");
}

#[test]
fn absolute_path_escapes_worktree() {
    assert_eq!(
        normalized_spec("/dev", "", "/path/to/repo").unwrap_err().to_string(),
        "The path '/dev' is not inside of the worktree '/path/to/repo'"
    );
}

fn normalized_spec(
    path: &str,
    prefix: &str,
    root: &str,
) -> Result<gix_pathspec::Pattern, gix_pathspec::normalize::Error> {
    let mut spec = gix_pathspec::parse(path.as_bytes(), Default::default()).expect("valid");
    spec.normalize(Path::new(prefix), Path::new(root))?;
    Ok(spec)
}