calepin 0.0.16

use anyhow::anyhow;
use std::io;
use std::path::{Path, PathBuf};

use crate::utils::path::is_path_like;
use crate::utils::tools::Tool;

pub fn validate_executable(
    program: &Path,
    action: &str,
    tool: Option<&Tool>,
) -> anyhow::Result<()> {
    if executable_exists(program) {
        Ok(())
    } else {
        Err(missing_executable_error(program, action, tool))
    }
}

pub fn spawn_error(
    program: &Path,
    action: &str,
    error: io::Error,
    tool: Option<&Tool>,
) -> anyhow::Error {
    if error.kind() == io::ErrorKind::NotFound {
        missing_executable_error(program, action, tool)
    } else {
        anyhow!(
            "failed to {action} with executable {}: {}",
            program.display(),
            error
        )
    }
}

fn missing_executable_error(program: &Path, action: &str, tool: Option<&Tool>) -> anyhow::Error {
    let hint = tool
        .map(|tool| format!(" {}", tool.install_hint))
        .unwrap_or_default();
    let configured = program.display();
    if is_path_like(program) {
        anyhow!("executable not found while trying to {action}: {configured}")
    } else {
        anyhow!("executable `{configured}` not found on PATH while trying to {action}.{hint}")
    }
}

fn executable_exists(program: &Path) -> bool {
    if is_path_like(program) {
        return is_executable_file(program);
    }
    std::env::var_os("PATH")
        .map(|path| {
            std::env::split_paths(&path).any(|dir| {
                path_candidates(&dir, program).any(|candidate| is_executable_file(&candidate))
            })
        })
        .unwrap_or(false)
}

fn path_candidates<'a>(dir: &'a Path, program: &'a Path) -> impl Iterator<Item = PathBuf> + 'a {
    let direct = std::iter::once(dir.join(program));
    #[cfg(windows)]
    {
        let has_extension = program.extension().is_some();
        let pathext = std::env::var_os("PATHEXT")
            .map(|value| {
                value
                    .to_string_lossy()
                    .split(';')
                    .filter(|extension| !extension.is_empty())
                    .map(|extension| {
                        let extension = extension.trim_start_matches('.');
                        dir.join(program).with_extension(extension)
                    })
                    .collect::<Vec<_>>()
            })
            .unwrap_or_else(|| {
                ["COM", "EXE", "BAT", "CMD"]
                    .into_iter()
                    .map(|extension| dir.join(program).with_extension(extension))
                    .collect()
            });
        return direct.chain((!has_extension).then_some(pathext).into_iter().flatten());
    }
    #[cfg(not(windows))]
    {
        direct
    }
}

#[cfg(unix)]
fn is_executable_file(path: &Path) -> bool {
    use std::os::unix::fs::PermissionsExt;

    path.metadata()
        .map(|metadata| metadata.is_file() && metadata.permissions().mode() & 0o111 != 0)
        .unwrap_or(false)
}

#[cfg(not(unix))]
fn is_executable_file(path: &Path) -> bool {
    path.is_file()
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::utils::testutil::{env_lock, EnvVarGuard};
    use std::path::PathBuf;

    #[test]
    fn missing_configured_path_names_the_path() {
        let error = spawn_error(
            &PathBuf::from("/tmp/missing-tool"),
            "run external tool",
            io::Error::from(io::ErrorKind::NotFound),
            None,
        )
        .to_string();

        assert!(error.contains("executable not found"));
        assert!(error.contains("/tmp/missing-tool"));
        assert!(error.contains("run external tool"));
    }

    #[test]
    fn missing_bare_command_names_path_lookup() {
        let error = spawn_error(
            Path::new("tool"),
            "run external tool",
            io::Error::from(io::ErrorKind::NotFound),
            None,
        )
        .to_string();

        assert!(error.contains("`tool` not found on PATH"));
        assert!(error.contains("run external tool"));
    }

    #[test]
    fn validate_accepts_executable_path() {
        let dir = tempfile::tempdir().unwrap();
        let executable = dir.path().join("tool");
        std::fs::write(&executable, "").unwrap();
        make_executable(&executable);

        validate_executable(&executable, "run external tool", None).unwrap();
    }

    #[test]
    fn validate_searches_path_for_bare_command() {
        let _env_lock = env_lock();
        let dir = tempfile::tempdir().unwrap();
        let executable = dir.path().join("tool");
        std::fs::write(&executable, "").unwrap();
        make_executable(&executable);
        let _path = EnvVarGuard::set("PATH", std::env::join_paths([dir.path()]).unwrap());

        validate_executable(Path::new("tool"), "run external tool", None).unwrap();
    }

    #[cfg(unix)]
    fn make_executable(path: &Path) {
        use std::os::unix::fs::PermissionsExt;

        let mut permissions = path.metadata().unwrap().permissions();
        permissions.set_mode(0o755);
        std::fs::set_permissions(path, permissions).unwrap();
    }

    #[cfg(not(unix))]
    fn make_executable(_path: &Path) {}
}