/**
 * @file lldir.cpp
 * @brief implementation of directory utilities base class
 *
 * $LicenseInfo:firstyear=2002&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "linden_common.h"

#if !LL_WINDOWS
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#else
#include <direct.h>
#endif

#include "lldir.h"

#include "llerror.h"
#include "lltimer.h"    // ms_sleep()
#include "lluuid.h"

#include "lldiriterator.h"
#include "stringize.h"
#include "llstring.h"
#include <boost/filesystem.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/bind.hpp>
#include <boost/ref.hpp>
#include <algorithm>

using boost::assign::list_of;
using boost::assign::map_list_of;

#if LL_WINDOWS
#include "lldir_win32.h"
LLDir_Win32 gDirUtil;
#elif LL_DARWIN
#include "lldir_mac.h"
LLDir_Mac gDirUtil;
#else
#include "lldir_linux.h"
LLDir_Linux gDirUtil;
#endif

LLDir *gDirUtilp = (LLDir *)&gDirUtil;

/// Values for findSkinnedFilenames(subdir) parameter
const char
    *LLDir::XUI      = "xui",
    *LLDir::TEXTURES = "textures",
    *LLDir::SKINBASE = "";

static const char* const empty = "";
std::string LLDir::sDumpDir = "";

LLDir::LLDir()
:   mAppName(""),
    mExecutablePathAndName(""),
    mExecutableFilename(""),
    mExecutableDir(""),
    mAppRODataDir(""),
    mOSUserDir(""),
    mOSUserAppDir(""),
    mLindenUserDir(""),
    mOSCacheDir(""),
    mCAFile(""),
    mTempDir(""),
    mDirDelimiter("/"), // fallback to forward slash if not overridden
    mLanguage("en"),
    mUserName("undefined")
{
}

LLDir::~LLDir()
{
}

std::vector<std::string> LLDir::getFilesInDir(const std::string &dirname)
{
    //Returns a vector of fullpath filenames.

#ifdef LL_WINDOWS // or BOOST_WINDOWS_API
    boost::filesystem::path p(utf8str_to_utf16str(dirname));
#else
    boost::filesystem::path p(dirname);
#endif

    std::vector<std::string> v;

    if (exists(p))
    {
        if (is_directory(p))
        {
            boost::filesystem::directory_iterator end_iter;
            for (boost::filesystem::directory_iterator dir_itr(p);
                 dir_itr != end_iter;
                 ++dir_itr)
            {
                if (boost::filesystem::is_regular_file(dir_itr->status()))
                {
                    v.push_back(dir_itr->path().filename().string());
                }
            }
        }
    }
    return v;
}

S32 LLDir::deleteFilesInDir(const std::string &dirname, const std::string &mask)
{
    S32 count = 0;
    std::string filename;
    std::string fullpath;
    S32 result;

    // File masks starting with "/" will match nothing, so we consider them invalid.
    if (LLStringUtil::startsWith(mask, getDirDelimiter()))
    {
        LL_WARNS() << "Invalid file mask: " << mask << LL_ENDL;
        llassert(!"Invalid file mask");
    }

    LLDirIterator iter(dirname, mask);
    while (iter.next(filename))
    {
        fullpath = add(dirname, filename);

        if(LLFile::isdir(fullpath))
        {
            // skipping directory traversal filenames
            count++;
            continue;
        }

        S32 retry_count = 0;
        while (retry_count < 5)
        {
            if (0 != LLFile::remove(fullpath))
            {
                retry_count++;
                result = errno;
                LL_WARNS() << "Problem removing " << fullpath << " - errorcode: "
                        << result << " attempt " << retry_count << LL_ENDL;

                if(retry_count >= 5)
                {
                    LL_WARNS() << "Failed to remove " << fullpath << LL_ENDL ;
                    return count ;
                }

                ms_sleep(100);
            }
            else
            {
                if (retry_count)
                {
                    LL_WARNS() << "Successfully removed " << fullpath << LL_ENDL;
                }
                break;
            }
        }
        count++;
    }
    return count;
}

U32 LLDir::deleteDirAndContents(const std::string& dir_name)
{
    //Removes the directory and its contents.  Returns number of files deleted.

    U32 num_deleted = 0;

    try
    {
#ifdef LL_WINDOWS // or BOOST_WINDOWS_API
        boost::filesystem::path dir_path(utf8str_to_utf16str(dir_name));
#else
        boost::filesystem::path dir_path(dir_name);
#endif

       if (boost::filesystem::exists(dir_path))
       {
          if (!boost::filesystem::is_empty(dir_path))
          {   // Directory has content
             num_deleted = (U32)boost::filesystem::remove_all(dir_path);
          }
          else
          {   // Directory is empty
             boost::filesystem::remove(dir_path);
          }
       }
    }
    catch (boost::filesystem::filesystem_error &er)
    {
        LL_WARNS() << "Failed to delete " << dir_name << " with error " << er.code().message() << LL_ENDL;
    }
    return num_deleted;
}

const std::string LLDir::findFile(const std::string &filename,
                           const std::string& searchPath1,
                           const std::string& searchPath2,
                           const std::string& searchPath3) const
{
    std::vector<std::string> search_paths;
    search_paths.push_back(searchPath1);
    search_paths.push_back(searchPath2);
    search_paths.push_back(searchPath3);
    return findFile(filename, search_paths);
}

const std::string LLDir::findFile(const std::string& filename, const std::vector<std::string> search_paths) const
{
    std::vector<std::string>::const_iterator search_path_iter;
    for (search_path_iter = search_paths.begin();
        search_path_iter != search_paths.end();
        ++search_path_iter)
    {
        if (!search_path_iter->empty())
        {
            std::string filename_and_path = (*search_path_iter);
            if (!filename.empty())
            {
                filename_and_path += getDirDelimiter() + filename;
            }
            if (fileExists(filename_and_path))
            {
                return filename_and_path;
            }
        }
    }
    return "";
}


const std::string &LLDir::getExecutablePathAndName() const
{
    return mExecutablePathAndName;
}

const std::string &LLDir::getExecutableFilename() const
{
    return mExecutableFilename;
}

const std::string &LLDir::getExecutableDir() const
{
    return mExecutableDir;
}

const std::string &LLDir::getWorkingDir() const
{
    return mWorkingDir;
}

const std::string &LLDir::getAppName() const
{
    return mAppName;
}

const std::string &LLDir::getAppRODataDir() const
{
    return mAppRODataDir;
}

const std::string &LLDir::getOSUserDir() const
{
    return mOSUserDir;
}

const std::string &LLDir::getOSUserAppDir() const
{
    return mOSUserAppDir;
}

const std::string &LLDir::getLindenUserDir() const
{
    if (mLindenUserDir.empty())
    {
        LL_DEBUGS() << "getLindenUserDir() called early, we don't have the user name yet - returning empty string to caller" << LL_ENDL;
    }

    return mLindenUserDir;
}

const std::string& LLDir::getChatLogsDir() const
{
    return mChatLogsDir;
}

void LLDir::setDumpDir( const std::string& path )
{
    LLDir::sDumpDir = path;
    if (LLStringUtil::endsWith(sDumpDir, mDirDelimiter))
    {
        sDumpDir.erase(sDumpDir.size() - mDirDelimiter.size());
    }
}

const std::string &LLDir::getDumpDir() const
{
    if (sDumpDir.empty() )
    {
        LLUUID uid;
        uid.generate();

        sDumpDir = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "")
                    + "dump-" + uid.asString();

        dir_exists_or_crash(sDumpDir);
    }

    return LLDir::sDumpDir;
}

bool LLDir::dumpDirExists() const
{
    return !sDumpDir.empty();
}

const std::string &LLDir::getPerAccountChatLogsDir() const
{
    return mPerAccountChatLogsDir;
}

const std::string &LLDir::getTempDir() const
{
    return mTempDir;
}

const std::string  LLDir::getCacheDir(bool get_default) const
{
    if (mCacheDir.empty() || get_default)
    {
        if (!mDefaultCacheDir.empty())
        {   // Set at startup - can't set here due to const API
            return mDefaultCacheDir;
        }

        std::string res = buildSLOSCacheDir();
        return res;
    }
    else
    {
        return mCacheDir;
    }
}

// Return the default cache directory
std::string LLDir::buildSLOSCacheDir() const
{
    std::string res;
    if (getOSCacheDir().empty())
    {
        if (getOSUserAppDir().empty())
        {
            res = "data";
        }
        else
        {
            res = add(getOSUserAppDir(), "cache");
        }
    }
    else
    {
        res = add(getOSCacheDir(), "Megapahit");
    }
    return res;
}



const std::string &LLDir::getOSCacheDir() const
{
    return mOSCacheDir;
}


const std::string &LLDir::getCAFile() const
{
    return mCAFile;
}

const std::string &LLDir::getDirDelimiter() const
{
    return mDirDelimiter;
}

const std::string& LLDir::getDefaultSkinDir() const
{
    return mDefaultSkinDir;
}

const std::string &LLDir::getSkinDir() const
{
    return mSkinDir;
}

const std::string &LLDir::getUserDefaultSkinDir() const
{
    return mUserDefaultSkinDir;
}

const std::string &LLDir::getUserSkinDir() const
{
    return mUserSkinDir;
}

const std::string LLDir::getSkinBaseDir() const
{
    return mSkinBaseDir;
}

const std::string &LLDir::getLLPluginDir() const
{
    return mLLPluginDir;
}

const std::string &LLDir::getUserName() const
{
    return mUserName;
}

static std::string ELLPathToString(ELLPath location)
{
    typedef std::map<ELLPath, const char*> ELLPathMap;
#define ENT(symbol) (symbol, #symbol)
    static const ELLPathMap sMap = map_list_of
        ENT(LL_PATH_NONE)
        ENT(LL_PATH_USER_SETTINGS)
        ENT(LL_PATH_APP_SETTINGS)
        ENT(LL_PATH_PER_SL_ACCOUNT) // returns/expands to blank string if we don't know the account name yet
        ENT(LL_PATH_CACHE)
        ENT(LL_PATH_CHARACTER)
        ENT(LL_PATH_HELP)
        ENT(LL_PATH_LOGS)
        ENT(LL_PATH_TEMP)
        ENT(LL_PATH_SKINS)
        ENT(LL_PATH_TOP_SKIN)
        ENT(LL_PATH_CHAT_LOGS)
        ENT(LL_PATH_PER_ACCOUNT_CHAT_LOGS)
        ENT(LL_PATH_USER_SKIN)
        ENT(LL_PATH_LOCAL_ASSETS)
        ENT(LL_PATH_EXECUTABLE)
        ENT(LL_PATH_DEFAULT_SKIN)
        ENT(LL_PATH_FONTS)
        ENT(LL_PATH_LAST)
    ;
#undef ENT

    ELLPathMap::const_iterator found = sMap.find(location);
    if (found != sMap.end())
        return found->second;
    return STRINGIZE("Invalid ELLPath value " << location);
}

std::string LLDir::getExpandedFilename(ELLPath location, const std::string& filename) const
{
    return getExpandedFilename(location, "", filename);
}

std::string LLDir::getExpandedFilename(ELLPath location, const std::string& subdir, const std::string& filename) const
{
    return getExpandedFilename(location, "", subdir, filename);
}

std::string LLDir::getExpandedFilename(ELLPath location, const std::string& subdir1, const std::string& subdir2, const std::string& in_filename) const
{
    std::string prefix;
    switch (location)
    {
    case LL_PATH_NONE:
        // Do nothing
        break;

    case LL_PATH_APP_SETTINGS:
        prefix = add(getAppRODataDir(), "app_settings");
        break;

    case LL_PATH_CHARACTER:
        prefix = add(getAppRODataDir(), "character");
        break;

    case LL_PATH_HELP:
        prefix = "help";
        break;

    case LL_PATH_CACHE:
        prefix = getCacheDir();
        break;

    case LL_PATH_DUMP:
        prefix=getDumpDir();
        break;

    case LL_PATH_USER_SETTINGS:
        prefix = add(getOSUserAppDir(), "user_settings");
        break;

    case LL_PATH_PER_SL_ACCOUNT:
        prefix = getLindenUserDir();
        if (prefix.empty())
        {
            // if we're asking for the per-SL-account directory but we haven't
            // logged in yet (or otherwise don't know the account name from
            // which to build this string), then intentionally return a blank
            // string to the caller and skip the below warning about a blank
            // prefix.
            LL_DEBUGS("LLDir") << "getLindenUserDir() not yet set: "
                               << ELLPathToString(location)
                               << ", '" << subdir1 << "', '" << subdir2 << "', '" << in_filename
                               << "' => ''" << LL_ENDL;
            return std::string();
        }
        break;

    case LL_PATH_CHAT_LOGS:
        prefix = getChatLogsDir();
        break;

    case LL_PATH_PER_ACCOUNT_CHAT_LOGS:
        prefix = getPerAccountChatLogsDir();
        if (prefix.empty())
        {
            // potentially directory was not set yet
            // intentionally return a blank string to the caller
            LL_DEBUGS("LLDir") << "Conversation log directory is not yet set" << LL_ENDL;
            return std::string();
        }
        break;

    case LL_PATH_LOGS:
        prefix = add(getOSUserAppDir(), "logs");
        break;

    case LL_PATH_TEMP:
        prefix = getTempDir();
        break;

    case LL_PATH_TOP_SKIN:
        prefix = getSkinDir();
        break;

    case LL_PATH_DEFAULT_SKIN:
        prefix = getDefaultSkinDir();
        break;

    case LL_PATH_USER_SKIN:
        prefix = getUserSkinDir();
        break;

    case LL_PATH_SKINS:
        prefix = getSkinBaseDir();
        break;

    case LL_PATH_LOCAL_ASSETS:
        prefix = add(getAppRODataDir(), "local_assets");
        break;

    case LL_PATH_EXECUTABLE:
        prefix = getExecutableDir();
        break;

    case LL_PATH_FONTS:
        prefix = add(getAppRODataDir(), "fonts");
        break;

    default:
        llassert(0);
    }

    if (prefix.empty())
    {
        LL_WARNS() << ELLPathToString(location)
                << ", '" << subdir1 << "', '" << subdir2 << "', '" << in_filename
                << "': prefix is empty, possible bad filename" << LL_ENDL;
    }

    std::string expanded_filename = add(prefix, subdir1, subdir2);
    if (expanded_filename.empty() && in_filename.empty())
    {
        return "";
    }
    // Use explicit concatenation here instead of another add() call. Callers
    // passing in_filename as "" expect to obtain a pathname ending with
    // mDirSeparator so they can later directly concatenate with a specific
    // filename. A caller using add() doesn't care, but there's still code
    // loose in the system that uses std::string::operator+().
    expanded_filename += mDirDelimiter;
    expanded_filename += in_filename;

    LL_DEBUGS("LLDir") << ELLPathToString(location)
                       << ", '" << subdir1 << "', '" << subdir2 << "', '" << in_filename
                       << "' => '" << expanded_filename << "'" << LL_ENDL;
    return expanded_filename;
}

std::string LLDir::getBaseFileName(const std::string& filepath, bool strip_exten) const
{
    std::size_t offset = filepath.find_last_of(getDirDelimiter());
    offset = (offset == std::string::npos) ? 0 : offset+1;
    std::string res = filepath.substr(offset, std::string::npos);
    if (strip_exten)
    {
        offset = res.find_last_of('.');
        if (offset != std::string::npos &&
            offset != 0) // if basename STARTS with '.', don't strip
        {
            res = res.substr(0, offset);
        }
    }
    return res;
}

std::string LLDir::getDirName(const std::string& filepath) const
{
    std::size_t offset = filepath.find_last_of(getDirDelimiter());
    auto len = (offset == std::string::npos) ? 0 : offset;
    std::string dirname = filepath.substr(0, len);
    return dirname;
}

std::string LLDir::getExtension(const std::string& filepath) const
{
    if (filepath.empty())
        return std::string();
    std::string basename = getBaseFileName(filepath, false);
    std::size_t offset = basename.find_last_of('.');
    std::string exten = (offset == std::string::npos || offset == 0) ? "" : basename.substr(offset+1);
    LLStringUtil::toLower(exten);
    return exten;
}

std::string LLDir::findSkinnedFilenameBaseLang(const std::string &subdir,
                                               const std::string &filename,
                                               ESkinConstraint constraint) const
{
    // This implementation is basically just as described in the declaration comments.
    std::vector<std::string> found(findSkinnedFilenames(subdir, filename, constraint));
    if (found.empty())
    {
        return "";
    }
    return found.front();
}

std::string LLDir::findSkinnedFilename(const std::string &subdir,
                                       const std::string &filename,
                                       ESkinConstraint constraint) const
{
    // This implementation is basically just as described in the declaration comments.
    std::vector<std::string> found(findSkinnedFilenames(subdir, filename, constraint));
    if (found.empty())
    {
        return "";
    }
    return found.back();
}

// This method exists because the two code paths for
// findSkinnedFilenames(ALL_SKINS) and findSkinnedFilenames(CURRENT_SKIN) must
// generate the list of candidate pathnames in identical ways. The only
// difference is in the body of the inner loop.
template <typename FUNCTION>
void LLDir::walkSearchSkinDirs(const std::string& subdir,
                               const std::vector<std::string>& subsubdirs,
                               const std::string& filename,
                               const FUNCTION& function) const
{
    for (std::string skindir : mSearchSkinDirs)
    {
        std::string subdir_path(add(skindir, subdir));
        for (const std::string& subsubdir : subsubdirs)
        {
            std::string full_path(add(subdir_path, subsubdir, filename));
            if (fileExists(full_path))
            {
                function(subsubdir, full_path);
            }
        }
    }
}

// ridiculous little helper function that should go away when we can use lambda
inline void push_back(std::vector<std::string>& vector, const std::string& value)
{
    vector.push_back(value);
}

typedef std::map<std::string, std::string> StringMap;
// ridiculous little helper function that should go away when we can use lambda
inline void store_in_map(StringMap& map, const std::string& key, const std::string& value)
{
    map[key] = value;
}

std::vector<std::string> LLDir::findSkinnedFilenames(const std::string& subdir,
                                                     const std::string& filename,
                                                     ESkinConstraint constraint) const
{
    // Recognize subdirs that have no localization.
    static const std::set<std::string> sUnlocalized = list_of
        ("")                        // top-level directory not localized
        ("textures")                // textures not localized
    ;

    LL_DEBUGS("LLDir") << "subdir '" << subdir << "', filename '" << filename
                       << "', constraint "
                       << ((constraint == CURRENT_SKIN)? "CURRENT_SKIN" : "ALL_SKINS")
                       << LL_ENDL;

    // Build results vector.
    std::vector<std::string> results;
    // Disallow filenames that may escape subdir
    if (filename.find("..") != std::string::npos)
    {
        LL_WARNS("LLDir") << "Ignoring potentially relative filename '" << filename << "'" << LL_ENDL;
        return results;
    }

    // Cache the default language directory for each subdir we've encountered.
    // A cache entry whose value is the empty string means "not localized,
    // don't bother checking again."
    static StringMap sLocalized;

    // Check whether we've already discovered if this subdir is localized.
    StringMap::const_iterator found = sLocalized.find(subdir);
    if (found == sLocalized.end())
    {
        // We have not yet determined that. Is it one of the subdirs "known"
        // to be unlocalized?
        if (sUnlocalized.find(subdir) != sUnlocalized.end())
        {
            // This subdir is known to be unlocalized. Remember that.
            found = sLocalized.insert(StringMap::value_type(subdir, "")).first;
        }
        else
        {
            // We do not recognize this subdir. Investigate.
            std::string subdir_path(add(getDefaultSkinDir(), subdir));
            if (fileExists(add(subdir_path, "en")))
            {
                // defaultSkinDir/subdir contains subdir "en". That's our
                // default language; this subdir is localized.
                found = sLocalized.insert(StringMap::value_type(subdir, "en")).first;
            }
            else if (fileExists(add(subdir_path, "en-us")))
            {
                // defaultSkinDir/subdir contains subdir "en-us" but not "en".
                // Set as default language; this subdir is localized.
                found = sLocalized.insert(StringMap::value_type(subdir, "en-us")).first;
            }
            else
            {
                // defaultSkinDir/subdir contains neither "en" nor "en-us".
                // Assume it's not localized. Remember that assumption.
                found = sLocalized.insert(StringMap::value_type(subdir, "")).first;
            }
        }
    }
    // Every code path above should have resulted in 'found' becoming a valid
    // iterator to an entry in sLocalized.
    llassert(found != sLocalized.end());

    // Now -- is this subdir localized, or not? The answer determines what
    // subdirectories we check (under subdir) for the requested filename.
    std::vector<std::string> subsubdirs;
    if (found->second.empty())
    {
        // subdir is not localized. filename should be located directly within it.
        subsubdirs.push_back("");
    }
    else
    {
        // subdir is localized, and found->second is the default language
        // directory within it. Check both the default language and the
        // current language -- if it differs from the default, of course.
        subsubdirs.push_back(found->second);
        if (mLanguage != found->second)
        {
            subsubdirs.push_back(mLanguage);
        }
    }

    // The process we use depends on 'constraint'.
    if (constraint != CURRENT_SKIN) // meaning ALL_SKINS
    {
        // ALL_SKINS is simpler: just return every pathname generated by
        // walkSearchSkinDirs(). Tricky bit: walkSearchSkinDirs() passes its
        // FUNCTION the subsubdir as well as the full pathname. We just want
        // the full pathname.
        walkSearchSkinDirs(subdir, subsubdirs, filename,
                           boost::bind(push_back, boost::ref(results), _2));
    }
    else                            // CURRENT_SKIN
    {
        // CURRENT_SKIN turns out to be a bit of a misnomer because we might
        // still return files from two different skins. In any case, this
        // value of 'constraint' means we will return at most two paths: one
        // for the default language, one for the current language (supposing
        // those differ).
        // It is important to allow a user to override only the localization
        // for a particular file, for all viewer installs, without also
        // overriding the default-language file.
        // It is important to allow a user to override only the default-
        // language file, for all viewer installs, without also overriding the
        // applicable localization of that file.
        // Therefore, treat the default language and the current language as
        // two separate cases. For each, capture the most-specialized file
        // that exists.
        // Use a map keyed by subsubdir (i.e. language code). This allows us
        // to handle the case of a single subsubdirs entry with the same logic
        // that handles two. For every real file path generated by
        // walkSearchSkinDirs(), update the map entry for its subsubdir.
        StringMap path_for;
        walkSearchSkinDirs(subdir, subsubdirs, filename,
                           boost::bind(store_in_map, boost::ref(path_for), _1, _2));
        // Now that we have a path for each of the default language and the
        // current language, copy them -- in proper order -- into results.
        // Don't drive this by walking the map itself: it matters that we
        // generate results in the same order as subsubdirs.
        for (const std::string& subsubdir : subsubdirs)
        {
            StringMap::const_iterator found(path_for.find(subsubdir));
            if (found != path_for.end())
            {
                results.push_back(found->second);
            }
        }
    }

    LL_DEBUGS("LLDir") << empty;
    const char* comma = "";
    for (const std::string& path : results)
    {
        LL_CONT << comma << "'" << path << "'";
        comma = ", ";
    }
    LL_CONT << LL_ENDL;

    return results;
}

std::string LLDir::getTempFilename() const
{
    LLUUID random_uuid;
    std::string uuid_str;

    random_uuid.generate();
    random_uuid.toString(uuid_str);

    return add(getTempDir(), uuid_str + ".tmp");
}

// static
std::string LLDir::getScrubbedFileName(std::string_view uncleanFileName)
{
    std::string name(uncleanFileName);
    const std::string illegalChars(getForbiddenFileChars());
    // replace any illegal file chars with and underscore '_'
    for (const char& ch : illegalChars)
    {
        std::string::size_type j{ 0 };
        while ((j = name.find(ch, j)) != std::string::npos)
        {
            name[j] = '_';
        }
    }
    return name;
}

std::string LLDir::getDumpLogsDirPath(const std::string &file_name)
{
    return gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "dump_logs", file_name);
}

// static
std::string LLDir::getForbiddenFileChars()
{
    return "\\/:*?\"<>|";
}

void LLDir::setLindenUserDir(const std::string &username)
{
    // if the username isn't set, that's bad
    if (!username.empty())
    {
        // some platforms have case-sensitive filesystems, so be
        // utterly consistent with our firstname/lastname case.
        std::string userlower(username);
        LLStringUtil::toLower(userlower);
        LLStringUtil::replaceChar(userlower, ' ', '_');
        mLindenUserDir = add(getOSUserAppDir(), userlower);
    }
    else
    {
        LL_ERRS() << "NULL name for LLDir::setLindenUserDir" << LL_ENDL;
    }

    dumpCurrentDirectories();
}

void LLDir::setChatLogsDir(const std::string &path)
{
    if (!path.empty() )
    {
        mChatLogsDir = path;
    }
    else
    {
        LL_WARNS() << "Invalid name for LLDir::setChatLogsDir" << LL_ENDL;
    }
}

void LLDir::updatePerAccountChatLogsDir()
{
    mPerAccountChatLogsDir = add(getChatLogsDir(), mUserName);
}

void LLDir::setPerAccountChatLogsDir(const std::string &username)
{
    // if both first and last aren't set, assume we're grabbing the cached dir
    if (!username.empty())
    {
        // some platforms have case-sensitive filesystems, so be
        // utterly consistent with our firstname/lastname case.
        std::string userlower(username);
        LLStringUtil::toLower(userlower);
        LLStringUtil::replaceChar(userlower, ' ', '_');

        mUserName = userlower;
        updatePerAccountChatLogsDir();
    }
    else
    {
        LL_ERRS() << "NULL name for LLDir::setPerAccountChatLogsDir" << LL_ENDL;
    }
}

void LLDir::setSkinFolder(const std::string &skin_folder, const std::string& language)
{
    LL_DEBUGS("LLDir") << "Setting skin '" << skin_folder << "', language '" << language << "'"
                       << LL_ENDL;
    mSkinName = skin_folder;
    mLanguage = language;

    // This method is called multiple times during viewer initialization. Each
    // time it's called, reset mSearchSkinDirs.
    mSearchSkinDirs.clear();

    // base skin which is used as fallback for all skinned files
    // e.g. c:\program files\secondlife\skins\default
    mDefaultSkinDir = getSkinBaseDir();
    append(mDefaultSkinDir, "default");
    // This is always the most general of the search skin directories.
    addSearchSkinDir(mDefaultSkinDir);

    mSkinDir = getSkinBaseDir();
    append(mSkinDir, skin_folder);
    // Next level of generality is a skin installed with the viewer.
    addSearchSkinDir(mSkinDir);

    // user modifications to skins, current and default
    // e.g. c:\documents and settings\users\username\application data\second life\skins\dazzle
    mUserSkinDir = getOSUserAppDir();
    append(mUserSkinDir, "skins");
    mUserDefaultSkinDir = mUserSkinDir;
    append(mUserDefaultSkinDir, "default");
    append(mUserSkinDir, skin_folder);
    // Next level of generality is user modifications to default skin...
    addSearchSkinDir(mUserDefaultSkinDir);
    // then user-defined skins.
    addSearchSkinDir(mUserSkinDir);
}

void LLDir::addSearchSkinDir(const std::string& skindir)
{
    if (std::find(mSearchSkinDirs.begin(), mSearchSkinDirs.end(), skindir) == mSearchSkinDirs.end())
    {
        LL_DEBUGS("LLDir") << "search skin: '" << skindir << "'" << LL_ENDL;
        mSearchSkinDirs.push_back(skindir);
    }
}

std::string LLDir::getSkinFolder() const
{
    return mSkinName;
}

std::string LLDir::getLanguage() const
{
    return mLanguage;
}

bool LLDir::setCacheDir(const std::string &path)
{
    if (path.empty() )
    {
        // reset to default
        mCacheDir = "";
        return true;
    }
    else
    {
        LLFile::mkdir(path);
        std::string tempname = add(path, "temp");
        LLFILE* file = LLFile::fopen(tempname,"wt");
        if (file)
        {
            fclose(file);
            LLFile::remove(tempname);
            mCacheDir = path;
            return true;
        }
        return false;
    }
}

void LLDir::dumpCurrentDirectories(LLError::ELevel level)
{
    LL_VLOGS(level, "AppInit","Directories") << "Current Directories:" << LL_ENDL;

    LL_VLOGS(level, "AppInit", "Directories") << "  CurPath:               " << getCurPath() << LL_ENDL;
    LL_VLOGS(level, "AppInit", "Directories") << "  AppName:               " << getAppName() << LL_ENDL;
    LL_VLOGS(level, "AppInit", "Directories") << "  ExecutableFilename:    " << getExecutableFilename() << LL_ENDL;
    LL_VLOGS(level, "AppInit", "Directories") << "  ExecutableDir:         " << getExecutableDir() << LL_ENDL;
    LL_VLOGS(level, "AppInit", "Directories") << "  ExecutablePathAndName: " << getExecutablePathAndName() << LL_ENDL;
    LL_VLOGS(level, "AppInit", "Directories") << "  WorkingDir:            " << getWorkingDir() << LL_ENDL;
    LL_VLOGS(level, "AppInit", "Directories") << "  AppRODataDir:          " << getAppRODataDir() << LL_ENDL;
    LL_VLOGS(level, "AppInit", "Directories") << "  OSUserDir:             " << getOSUserDir() << LL_ENDL;
    LL_VLOGS(level, "AppInit", "Directories") << "  OSUserAppDir:          " << getOSUserAppDir() << LL_ENDL;
    LL_VLOGS(level, "AppInit", "Directories") << "  LindenUserDir:         " << getLindenUserDir() << LL_ENDL;
    LL_VLOGS(level, "AppInit", "Directories") << "  TempDir:               " << getTempDir() << LL_ENDL;
    LL_VLOGS(level, "AppInit", "Directories") << "  CAFile:                " << getCAFile() << LL_ENDL;
    LL_VLOGS(level, "AppInit", "Directories") << "  SkinBaseDir:           " << getSkinBaseDir() << LL_ENDL;
    LL_VLOGS(level, "AppInit", "Directories") << "  SkinDir:               " << getSkinDir() << LL_ENDL;
}

void LLDir::append(std::string& destpath, const std::string& name) const
{
    // Delegate question of whether we need a separator to helper method.
    SepOff sepoff(needSep(destpath, name));
    if (sepoff.first)               // do we need a separator?
    {
        destpath += mDirDelimiter;
    }
    // If destpath ends with a separator, AND name starts with one, skip
    // name's leading separator.
    destpath += name.substr(sepoff.second);
}

LLDir::SepOff LLDir::needSep(const std::string& path, const std::string& name) const
{
    if (path.empty() || name.empty())
    {
        // If either path or name are empty, we do not need a separator
        // between them.
        return SepOff(false, 0);
    }
    // Here we know path and name are both non-empty. But if path already ends
    // with a separator, or if name already starts with a separator, we need
    // not add one.
    std::string::size_type seplen(mDirDelimiter.length());
    bool path_ends_sep(path.substr(path.length() - seplen) == mDirDelimiter);
    bool name_starts_sep(name.substr(0, seplen) == mDirDelimiter);
    if ((! path_ends_sep) && (! name_starts_sep))
    {
        // If neither path nor name brings a separator to the junction, then
        // we need one.
        return SepOff(true, 0);
    }
    if (path_ends_sep && name_starts_sep)
    {
        // But if BOTH path and name bring a separator, we need not add one.
        // Moreover, we should actually skip the leading separator of 'name'.
        return SepOff(false, (unsigned short)seplen);
    }
    // Here we know that either path_ends_sep or name_starts_sep is true --
    // but not both. So don't add a separator, and don't skip any characters:
    // simple concatenation will do the trick.
    return SepOff(false, 0);
}

void dir_exists_or_crash(const std::string &dir_name)
{
#if LL_WINDOWS
    // *FIX: lame - it doesn't do the same thing on windows. not so
    // important since we don't deploy simulator to windows boxes.
    LLFile::mkdir(dir_name, 0700);
#else
    struct stat dir_stat;
    if(0 != LLFile::stat(dir_name, &dir_stat))
    {
        S32 stat_rv = errno;
        if(ENOENT == stat_rv)
        {
           if(0 != LLFile::mkdir(dir_name, 0700))       // octal
           {
               LL_ERRS() << "Unable to create directory: " << dir_name << LL_ENDL;
           }
        }
        else
        {
            LL_ERRS() << "Unable to stat: " << dir_name << " errno = " << stat_rv
                   << LL_ENDL;
        }
    }
    else
    {
        // data_dir exists, make sure it's a directory.
        if(!S_ISDIR(dir_stat.st_mode))
        {
            LL_ERRS() << "Data directory collision: " << dir_name << LL_ENDL;
        }
    }
#endif
}