yog 0.0.1

use super::*;

/// A fold under test, a hermetic env as pairs, and the path it must yield.
type Case = (
    fn(&Env) -> PathBuf,
    &'static [(&'static str, &'static str)],
    &'static str,
);

fn run(cases: &[Case]) {
    for &(fold, vars, expect) in cases {
        let env = Env::from_pairs(vars.iter().copied());
        assert_eq!(fold(&env), PathBuf::from(expect), "vars={vars:?}");
    }
}

#[test]
fn xdg_folds_set_unset_and_missing_home() {
    run(&[
        // balls: XDG set, XDG unset (HOME set), both missing.
        (
            Env::balls_state_root,
            &[("XDG_STATE_HOME", "/x")],
            "/x/balls",
        ),
        (
            Env::balls_state_root,
            &[("HOME", "/h")],
            "/h/.local/state/balls",
        ),
        (Env::balls_state_root, &[], ".local/state/balls"),
        (
            Env::balls_clones_dir,
            &[("XDG_STATE_HOME", "/x")],
            "/x/balls/clones",
        ),
        (
            Env::balls_clones_dir,
            &[("HOME", "/h")],
            "/h/.local/state/balls/clones",
        ),
        // yog data + state.
        (Env::yog_data_root, &[("XDG_DATA_HOME", "/d")], "/d/yog"),
        (Env::yog_data_root, &[("HOME", "/h")], "/h/.local/share/yog"),
        (Env::yog_data_root, &[], ".local/share/yog"),
        (Env::yog_state_root, &[("XDG_STATE_HOME", "/x")], "/x/yog"),
        (
            Env::yog_state_root,
            &[("HOME", "/h")],
            "/h/.local/state/yog",
        ),
        // yog scripted-editor staging root (§9.3): state root + `stage`.
        (
            Env::yog_stage_root,
            &[("XDG_STATE_HOME", "/x")],
            "/x/yog/stage",
        ),
        (
            Env::yog_stage_root,
            &[("HOME", "/h")],
            "/h/.local/state/yog/stage",
        ),
        // home dir (`~`, §3.4 bare rung cwd): HOME verbatim, else the root `/`
        // (a real dir, never cwd "").
        (Env::home_dir, &[("HOME", "/h")], "/h"),
        (Env::home_dir, &[], "/"),
    ]);
}

#[test]
fn lernie_roots_home_collapse_set_empty_unset() {
    run(&[
        // LERNIE_HOME set and non-empty: both roots collapse onto it,
        // even with XDG vars present.
        (
            Env::lernie_config_root,
            &[("LERNIE_HOME", "/L"), ("XDG_CONFIG_HOME", "/c")],
            "/L",
        ),
        (
            Env::lernie_data_root,
            &[("LERNIE_HOME", "/L"), ("XDG_DATA_HOME", "/d")],
            "/L",
        ),
        // Empty LERNIE_HOME falls through to the XDG fold.
        (
            Env::lernie_config_root,
            &[("LERNIE_HOME", ""), ("XDG_CONFIG_HOME", "/c")],
            "/c/lernie",
        ),
        (
            Env::lernie_data_root,
            &[("LERNIE_HOME", ""), ("XDG_DATA_HOME", "/d")],
            "/d/lernie",
        ),
        // Unset LERNIE_HOME: XDG, then HOME default, then bare relative.
        (
            Env::lernie_config_root,
            &[("XDG_CONFIG_HOME", "/c")],
            "/c/lernie",
        ),
        (
            Env::lernie_config_root,
            &[("HOME", "/h")],
            "/h/.config/lernie",
        ),
        (Env::lernie_config_root, &[], ".config/lernie"),
        (
            Env::lernie_data_root,
            &[("HOME", "/h")],
            "/h/.local/share/lernie",
        ),
        (Env::lernie_data_root, &[], ".local/share/lernie"),
    ]);
}

#[test]
fn brazen_config_fold() {
    run(&[
        // $BRAZEN_CONFIG wins outright, even over XDG.
        (
            Env::brazen_config_path,
            &[("BRAZEN_CONFIG", "/b.toml"), ("XDG_CONFIG_HOME", "/c")],
            "/b.toml",
        ),
        // Empty BRAZEN_CONFIG falls through.
        (
            Env::brazen_config_path,
            &[("BRAZEN_CONFIG", ""), ("XDG_CONFIG_HOME", "/c")],
            "/c/brazen/config.toml",
        ),
        (
            Env::brazen_config_path,
            &[("HOME", "/h")],
            "/h/.config/brazen/config.toml",
        ),
        (Env::brazen_config_path, &[], ".config/brazen/config.toml"),
    ]);
}

#[test]
fn brazen_per_os_credentials_and_cache() {
    run(&[
        // Linux: XDG data/cache, then HOME defaults.
        (
            |e| e.brazen_credentials_dir(Os::Linux),
            &[("XDG_DATA_HOME", "/d")],
            "/d/brazen/credentials",
        ),
        (
            |e| e.brazen_credentials_dir(Os::Linux),
            &[("HOME", "/h")],
            "/h/.local/share/brazen/credentials",
        ),
        (
            |e| e.brazen_models_cache_dir(Os::Linux),
            &[("XDG_CACHE_HOME", "/k")],
            "/k/brazen/models",
        ),
        (
            |e| e.brazen_models_cache_dir(Os::Linux),
            &[("HOME", "/h")],
            "/h/.cache/brazen/models",
        ),
        // macOS: ~/Library, ignoring XDG entirely.
        (
            |e| e.brazen_credentials_dir(Os::MacOs),
            &[("HOME", "/h"), ("XDG_DATA_HOME", "/d")],
            "/h/Library/Application Support/brazen/credentials",
        ),
        (
            |e| e.brazen_models_cache_dir(Os::MacOs),
            &[("HOME", "/h"), ("XDG_CACHE_HOME", "/k")],
            "/h/Library/Caches/brazen/models",
        ),
        // macOS with HOME missing: bare relative Library path.
        (
            |e| e.brazen_credentials_dir(Os::MacOs),
            &[],
            "Library/Application Support/brazen/credentials",
        ),
    ]);
}

#[test]
fn percent_decode_table() {
    let cases = [
        ("home%2Fmark", "home/mark"), // uppercase hex
        ("home%2fmark", "home/mark"), // lowercase hex
        ("a%20b", "a b"),             // digits
        ("plain", "plain"),           // no escape
        ("", ""),                     // empty
        ("%GG", "%GG"),               // invalid hex, verbatim
        ("tail%", "tail%"),           // trailing %, verbatim
        ("x%4", "x%4"),               // incomplete escape, verbatim
        ("%41%42", "AB"),             // consecutive escapes
    ];
    for (input, expect) in cases {
        assert_eq!(percent_decode(input), expect, "input={input:?}");
    }
}

#[test]
fn user_reads_the_snapshot_and_empty_is_absent() {
    assert_eq!(
        Env::from_pairs([("USER", "orion")]).user().as_deref(),
        Some("orion"),
    );
    // Empty and unset both read as absent (the module's `get` convention).
    assert_eq!(Env::from_pairs([("USER", "")]).user(), None);
    assert_eq!(
        Env::from_pairs(std::iter::empty::<(&str, &str)>()).user(),
        None
    );
}

#[test]
fn current_os_is_the_compiled_target() {
    let os = current_os();
    #[cfg(target_os = "macos")]
    assert_eq!(os, Os::MacOs);
    #[cfg(not(target_os = "macos"))]
    assert_eq!(os, Os::Linux);
}

#[test]
fn from_env_snapshots_process_env() {
    // Exercises the one real-env bridge; contents are host-dependent, so we
    // only assert it constructs and folds without panicking.
    let env = Env::from_env();
    let _ = env.yog_state_root();
}