/**
 * Searching for executable files in system paths.
 * Authors: 
 *  $(LINK2 https://github.com/MyLittleRobo, Roman Chistokhodov)
 * License: 
 *  $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
 * Copyright:
 *  Roman Chistokhodov 2016
 */

module findexecutable;

private {
    import std.algorithm : canFind, splitter, filter;
    import std.exception : collectException;
    import std.file : isFile;
    import std.path;
    import std.process : environment;
    import std.range;
    import std.string : toStringz, toLower;
    import std.uni : sicmp;
}

version(Windows) {
    private enum pathVarSeparator = ';';
    private enum defaultExts = ".exe;.com;.bat;.cmd";
} else version(Posix) {
    private enum pathVarSeparator = ':';
}

version(unittest) {
    import std.algorithm : equal;
    
    private struct EnvGuard
    {
        this(string env) {
            envVar = env;
            envValue = environment.get(env);
        }
        
        ~this() {
            if (envValue is null) {
                environment.remove(envVar);
            } else {
                environment[envVar] = envValue;
            }
        }
        
        string envVar;
        string envValue;
    }
}

/**
 * Default executable extensions for the current system.
 * On Windows this functions examines PATHEXT environment variable to get the list of executables extensions.
 * On other systems it always returns empty range.
 */
@trusted auto executableExtensions() nothrow
{
    version(Windows) {
        static bool filenamesEqual(string first, string second) nothrow {
            try {
                return filenameCmp(first, second) == 0;
            } catch(Exception e) {
                return false;
            }
        }
        
        static auto splitValues(string pathExt) {
            return pathExt.splitter(pathVarSeparator);
        }
        
        try {
            auto pathExts = splitValues(environment.get("PATHEXT"));
            if (canFind!(filenamesEqual)(pathExts, ".exe") == false) {
                return splitValues(defaultExts);
            } else {
                return pathExts;
            }
        } catch(Exception e) {
            return splitValues(defaultExts);
        }
        
    } else {
        return (string[]).init;
    }
}

///
unittest
{
    version(Windows) {
        auto guard = EnvGuard("PATHEXT");
        environment["PATHEXT"] = ".exe;.bat;.cmd";
        assert(equal(executableExtensions(), [".exe", ".bat", ".cmd"]));
        environment["PATHEXT"] = "";
        assert(equal(executableExtensions(), defaultExts.splitter(pathVarSeparator)));
    } else {
        assert(executableExtensions().empty);
    }
}

private bool isExecutable(Exts)(string filePath, Exts exts) nothrow {
    try {
        version(Posix) {
            import core.sys.posix.unistd;
            return access(toStringz(filePath), X_OK) == 0;
        } else version(Windows) {
            //Use GetEffectiveRightsFromAclW?
            
            string extension = filePath.extension;
            foreach(ext; exts) {
                if (sicmp(extension, ext) == 0)
                    return true;
            }
            return false;
            
        } else {
            static assert(false, "Unsupported platform");
        }
    } catch(Exception e) {
        return false;
    }
}

private string checkExecutable(Exts)(string filePath, Exts exts) nothrow {
    try {
        if (filePath.isFile && isExecutable(filePath, exts)) {
            return buildNormalizedPath(filePath);
        } else {
            return null;
        }
    }
    catch(Exception e) {
        return null;
    }
}

/**
 * System paths where executable files can be found.
 * Returns: Range of non-empty paths as determined by $(B PATH) environment variable.
 * Note: this function does not cache its result
 */
@trusted auto binPaths()
{
    string pathVar;
    collectException(environment.get("PATH"), pathVar);
    return splitter(pathVar, pathVarSeparator).filter!(p => p.length != 0);
}

///
unittest
{
    auto pathGuard = EnvGuard("PATH");
    version(Windows) {
        environment["PATH"] = ".;C:\\Windows\\system32;C:\\Program Files";
        assert(equal(binPaths(), [".", "C:\\Windows\\system32", "C:\\Program Files"]));
    } else {
        environment["PATH"] = ".:/usr/apps:/usr/local/apps:";
        assert(equal(binPaths(), [".", "/usr/apps", "/usr/local/apps"]));
    }
}

/**
 * Find executable by fileName in the paths.
 * Returns: Absolute path to the existing executable file or an empty string if not found.
 * Params:
 *  fileName = Name of executable to search. Should be base name or absolute path. Relative paths will not work.
 *       If it's an absolute path, this function does not try to append extensions.
 *  paths = Range of directories where executable should be searched.
 *  extensions = Range of extensions to append during searching if fileName does not have extension.
 * See_Also: binPaths, executableExtensions
 */
string findExecutable(Paths, Exts)(string fileName, Paths paths, Exts extensions) 
if (isInputRange!Paths && is(ElementType!Paths : string) && isInputRange!Exts && is(ElementType!Exts : string))
{   
    try {
        if (fileName.isAbsolute()) {
            return checkExecutable(fileName, extensions);
        } else if (fileName == fileName.baseName) {
            string toReturn;
            foreach(string path; paths) {
                if (path.empty) {
                    continue;
                }
                
                string candidate = buildPath(absolutePath(path), fileName);
                
                if (candidate.extension.empty && !extensions.empty) {
                    foreach(exeExtension; extensions) {
                        version(Windows) {
                            exeExtension = exeExtension.toLower();
                        }
                        toReturn = checkExecutable(setExtension(candidate, exeExtension), extensions);
                        if (toReturn.length) {
                            return toReturn;
                        }
                    }
                }
                
                toReturn = checkExecutable(candidate, extensions);
                if (toReturn.length) {
                    return toReturn;
                }
            }
        }
    } catch (Exception e) {
        
    }
    return null;
}

/**
 * ditto, but on Windows when fileName extension is omitted, executable extensions are appended during search.
 * See_Also: binPaths, executableExtensions
 */
string findExecutable(Paths)(string fileName, Paths paths) 
if (isInputRange!Paths && is(ElementType!Paths : string))
{
    return findExecutable(fileName, paths, executableExtensions());
}

/**
 * ditto, but searches in system paths, determined by $(B PATH) environment variable.
 * On Windows when fileName extension is omitted, executable extensions are appended during search.
 * See_Also: binPaths, executableExtensions
 */
@trusted string findExecutable(string fileName) nothrow {
    try {
        return findExecutable(fileName, binPaths(), executableExtensions());
    } catch(Exception e) {
        return null;
    }
}