roundabout

use std::{

    env, fs,

    os::unix::fs::{DirBuilderExt, PermissionsExt},

    path::{Path, PathBuf},

};

fn home() -> PathBuf {

    env::var_os("HOME").map_or_else(|| PathBuf::from("/"), PathBuf::from)

}

fn xdg(var: &str, fallback: &str) -> PathBuf {

    env::var_os(var)

        .map(PathBuf::from)

        .filter(|p| p.is_absolute())

        .unwrap_or_else(|| home().join(fallback))

}

pub fn config_file() -> PathBuf {

    if let Some(p) = env::var_os("ROUNDABOUT_CONFIG") {

        return p.into();

    }

    let user = xdg("XDG_CONFIG_HOME", ".config").join("roundabout/config.toml");

    let system = PathBuf::from("/etc/roundabout/config.toml");

    if !user.exists() && system.exists() {

        system

    } else {

        user

    }

}

pub fn state_dir() -> PathBuf {

    let dir = env::var_os("ROUNDABOUT_STATE_DIR").map_or_else(

        || xdg("XDG_STATE_HOME", ".local/state").join("roundabout"),

        PathBuf::from,

    );

    let _ = fs::create_dir_all(&dir);

    dir

}

pub fn runtime_dir() -> PathBuf {

    if let Some(dir) = env::var_os("ROUNDABOUT_RUNTIME_DIR") {

        let dir = PathBuf::from(dir);

        let _ = fs::DirBuilder::new()

            .recursive(true)

            .mode(0o700)

            .create(&dir);

        return dir;

    }

    if let Some(dir) = env::var_os("XDG_RUNTIME_DIR").map(PathBuf::from)

        && dir.is_absolute()

        && dir.is_dir()

    {

        return dir;

    }

    let uid = unsafe { libc::getuid() };

    let dir = env::temp_dir().join(format!("roundabout-{uid}"));

    let _ = fs::DirBuilder::new().mode(0o700).create(&dir);

    let _ = fs::set_permissions(&dir, fs::Permissions::from_mode(0o700));

    dir

}

pub fn socket() -> PathBuf {

    runtime_dir().join("roundabout.sock")

}

pub fn spawn_lock() -> PathBuf {

    runtime_dir().join("roundabout.lock")

}

pub fn git_root(cwd: &Path) -> Option<PathBuf> {

    cwd.ancestors()

        .find(|dir| dir.join(".git").exists())

        .map(Path::to_path_buf)

}

pub fn project_config_file(cwd: &Path) -> Option<PathBuf> {

    let root = git_root(cwd)?;

    for dir in cwd.ancestors() {

        if dir.join(".resrc").is_file() {

            return Some(dir.join(".resrc"));

        }

        if dir == root {

            break;

        }

    }

    None

}

pub fn project_root(cwd: &Path) -> PathBuf {

    const MARKERS: [&str; 6] = [

        ".jj",

        ".git",

        ".hg",

        "flake.nix",

        "Cargo.toml",

        "package.json",

    ];

    let mut best = None;

    for dir in cwd.ancestors() {

        if dir.join(".jj").exists() || dir.join(".git").exists() || dir.join(".hg").exists() {

            return dir.to_path_buf();

        }

        if best.is_none() && MARKERS.iter().any(|m| dir.join(m).exists()) {

            best = Some(dir.to_path_buf());

        }

    }

    best.unwrap_or_else(|| cwd.to_path_buf())

}

#[cfg(test)]

mod tests {

    use std::{

        fs,

        path::PathBuf,

        time::{SystemTime, UNIX_EPOCH},

    };

    use super::project_config_file;

    fn temp_tree() -> PathBuf {

        let stamp = SystemTime::now()

            .duration_since(UNIX_EPOCH)

            .expect("clock before epoch")

            .as_nanos();

        let root = std::env::temp_dir().join(format!("roundabout-paths-{stamp}"));

        fs::create_dir_all(&root).expect("create temporary tree");

        root

    }

    #[test]

    fn project_config_is_nearest_and_git_bounded() {

        let outer = temp_tree();

        let root = outer.join("repo");

        fs::create_dir(&root).expect("create repository tree");

        let child = root.join("child");

        let nested = child.join("nested");

        fs::create_dir_all(&nested).expect("create nested tree");

        fs::create_dir(root.join(".git")).expect("create git marker");

        fs::write(root.join(".resrc"), "").expect("write root config");

        fs::write(child.join(".resrc"), "").expect("write child config");

        fs::write(nested.join(".resrc"), "").expect("write nested config");

        assert_eq!(project_config_file(&nested), Some(nested.join(".resrc")));

        fs::remove_file(nested.join(".resrc")).expect("remove nested config");

        assert_eq!(project_config_file(&nested), Some(child.join(".resrc")));

        fs::remove_file(child.join(".resrc")).expect("remove child config");

        assert_eq!(project_config_file(&nested), Some(root.join(".resrc")));

        fs::remove_file(root.join(".resrc")).expect("remove root config");

        fs::write(outer.join(".resrc"), "").expect("write outside config");

        assert_eq!(project_config_file(&nested), None);

        fs::remove_file(outer.join(".resrc")).expect("remove outside config");

        fs::remove_dir_all(outer).expect("remove temporary tree");

    }

}