//! The core functionality
//!
//! See [crate-level documentation](../index.html) for more information on this module.

use {
    crate::{
        util::{is_executable, is_executable_path, split_path_env},
        IchwhError, IchwhResult,
    },
    async_std::{
        fs::read_dir,
        path::{Path, PathBuf},
    },
    futures::stream::StreamExt,
};

#[cfg(windows)]
use {
    crate::util::{filename_matches, pathext},
    std::collections::HashMap,
};

/// Searches `PATH` for an executable with the name `bin`. The core functionality of the `which`
/// command
///
/// # Errors
///
/// * Binary is not found
/// * PATH is not defined as an environment variable
/// * An IO error occurs
pub async fn which(bin: &str) -> IchwhResult<PathBuf> {
    #[cfg(unix)]
    let is_path = bin.contains('/');
    #[cfg(windows)]
    let is_path = bin.contains('\\');

    if is_path {
        // It's an absolute or relative path, so see if it points to an executable file
        let path = Path::new(bin);
        if let Some(actual_path) = is_executable_path(&path).await? {
            return Ok(actual_path);
        } else {
            return Err(IchwhError::BinaryNotFound(bin.to_string()));
        }
    }

    let dirs = split_path_env()?;

    for dir in dirs {
        let res = which_in_dir(&bin, &dir).await?;
        if let Some(res) = res {
            return Ok(res);
        }
    }

    Err(IchwhError::BinaryNotFound(bin.to_string()))
}

/// Searches `PATH` for all executables with the name `bin`. Returns a list of paths, in the order
/// of which they were found.
pub async fn which_all(bin: &str) -> IchwhResult<Vec<PathBuf>> {
    if bin.contains('/') {
        // It's an absolute or relative path, so see if it points to an executable file
        let path = Path::new(bin);
        if let Some(actual_path) = is_executable_path(&path).await? {
            return Ok(vec![actual_path]);
        } else {
            return Err(IchwhError::BinaryNotFound(bin.to_string()));
        }
    }

    let dirs = split_path_env()?;

    let mut rtn = Vec::new();

    for dir in dirs {
        #[cfg(unix)]
        {
            let res = which_in_dir(&bin, &dir).await?;
            if let Some(res) = res {
                rtn.push(res);
            }
        }
        #[cfg(windows)]
        {
            let res = which_all_in_dir(&bin, &dir).await?;
            rtn.extend(res);
        }
    }

    Ok(rtn)
}

/// Searches a directory for an exexcutable with the name `bin`.
///
/// # Errors
///
/// * An IO error occurs
pub async fn which_in_dir<P: AsRef<Path>>(bin: &str, path: P) -> IchwhResult<Option<PathBuf>> {
    #[cfg(windows)]
    {
        let matching_entries = which_all_in_dir(bin, path).await?;

        Ok(matching_entries.get(0).cloned())
    }

    #[cfg(unix)]
    {
        let mut entries = read_dir(path).await?;

        while let Some(entry) = entries.next().await {
            let entry = entry?;

            if is_executable(&entry).await? && entry.file_name() == bin {
                return Ok(Some(entry.path()));
            }
        }

        Ok(None)
    }
}

/// Find all executable files that could possibly match in a given directory,
/// sorted by their extensions' appearance in %PATHEXT%
#[cfg(windows)]
pub(crate) async fn which_all_in_dir<P: AsRef<Path>>(
    bin: &str,
    path: P,
) -> IchwhResult<Vec<PathBuf>> {
    let mut matches = read_dir(path)
        .await?
        .filter_map(|entry| {
            async {
                if let Ok(entry) = entry {
                    let is_exec = is_executable(&entry).await;
                    if is_exec.is_ok() && is_exec.unwrap() && filename_matches(&bin, &entry) {
                        return Some(entry.path());
                    }
                }
                None
            }
        })
        .collect::<Vec<_>>()
        .await;

    // Create a lookup table for executable extensions (extension --maps-> index)
    let exts = pathext()?; // need this for lifetime reasons
    let exts = exts
        .iter()
        .enumerate()
        .map(|(a, b)| (b, a))
        .collect::<HashMap<_, _>>();

    // Sort the matches by their extensions' appearance in PATHEXT
    matches.sort_by(|a, b| {
        let a_ext = a
            .extension()
            .unwrap()
            .to_string_lossy()
            .to_ascii_uppercase();
        let b_ext = b
            .extension()
            .unwrap()
            .to_string_lossy()
            .to_ascii_uppercase();

        exts[&a_ext].cmp(&exts[&b_ext])
    });

    Ok(matches)
}