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 {

    env::var_os("ROUNDABOUT_CONFIG").map_or_else(

        || xdg("XDG_CONFIG_HOME", ".config").join("roundabout/config.toml"),

        PathBuf::from,

    )

}

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 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())

}