/*
 * Copyright 2015, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2013, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <find_directory_private.h>

#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>

#include <algorithm>

#include <fs_attr.h>

#include <architecture_private.h>
#include <AutoDeleter.h>
#include <directories.h>
#include <syscalls.h>

#include "PathBuffer.h"


static size_t kHomeInstallationLocationIndex = 1;

static const path_base_directory kArchitectureSpecificBaseDirectories[] = {
        B_FIND_PATH_ADD_ONS_DIRECTORY,
        B_FIND_PATH_BIN_DIRECTORY,
        B_FIND_PATH_DEVELOP_LIB_DIRECTORY,
        B_FIND_PATH_HEADERS_DIRECTORY,
};

static size_t kArchitectureSpecificBaseDirectoryCount =
        sizeof(kArchitectureSpecificBaseDirectories)
                / sizeof(kArchitectureSpecificBaseDirectories[0]);


namespace {


struct InstallationLocations {
public:
        static const size_t     kCount = 4;

public:
        InstallationLocations()
                :
                fReferenceCount(1)
        {
                fLocations[0] = kUserNonpackagedDirectory;
                fLocations[1] = kUserConfigDirectory;
                fLocations[2] = kSystemNonpackagedDirectory;
                fLocations[3] = kSystemDirectory;
        }

        InstallationLocations(const char* home)
                :
                fReferenceCount(1)
        {
                static const char* const kNonPackagedSuffix = "/non-packaged";
                char* homeNonPackaged
                        = (char*)malloc(strlen(home) + strlen(kNonPackagedSuffix) + 1);
                fLocations[0] = homeNonPackaged;
                if (homeNonPackaged != NULL) {
                        strcpy(homeNonPackaged, home);
                        strcat(homeNonPackaged, kNonPackagedSuffix);
                }

                fLocations[1] = strdup(home);

                fLocations[2] = kSystemNonpackagedDirectory;
                fLocations[3] = kSystemDirectory;
        }

        ~InstallationLocations()
        {
                free(const_cast<char*>(fLocations[0]));
                free(const_cast<char*>(fLocations[1]));
        }

        bool IsValid() const
        {
                return fLocations[0] != NULL && fLocations[1] != NULL;
        }

        bool IsUserIndex(size_t index) const
        {
                return index==0 || index==1;
        }

        bool IsSystemIndex(size_t index) const
        {
                return index==2 || index==3;
        }

        static InstallationLocations* Default()
        {
                static char sBuffer[sizeof(InstallationLocations)];
                static InstallationLocations* sDefaultLocations
                        = new(&sBuffer) InstallationLocations;
                return sDefaultLocations;
        }

        static InstallationLocations* Get()
        {
                InstallationLocations* defaultLocations = Default();

                // Get the home config installation location and create a new object,
                // if it differs from the default.
                char homeInstallationLocation[B_PATH_NAME_LENGTH];
                if (__find_directory(B_USER_CONFIG_DIRECTORY, -1, false,
                                        homeInstallationLocation, sizeof(homeInstallationLocation))
                                == B_OK) {
                        _kern_normalize_path(homeInstallationLocation, true,
                                homeInstallationLocation);
                                // failure is OK
                        if (strcmp(homeInstallationLocation,
                                                defaultLocations->At(kHomeInstallationLocationIndex))
                                        != 0) {
                                InstallationLocations* locations
                                        = new(std::nothrow) InstallationLocations(
                                                homeInstallationLocation);
                                if (locations != NULL && locations->IsValid())
                                        return locations;
                                delete locations;
                        }
                }

                atomic_add(&defaultLocations->fReferenceCount, 1);
                return defaultLocations;
        }

        void Put()
        {
                if (atomic_add(&fReferenceCount, -1) == 1)
                        delete this;
        }

        const char* At(size_t index) const
        {
                return fLocations[index];
        }

        const char* LocationFor(const char* path, size_t& _index)
        {
                for (size_t i = 0; i < kCount; i++) {
                        size_t length = strlen(fLocations[i]);
                        if (strncmp(path, fLocations[i], length) == 0
                                && (path[length] == '/' || path[length] == '\0')) {
                                _index = i;
                                return fLocations[i];
                        }
                }

                return NULL;
        }

private:
        int32           fReferenceCount;
        const char*     fLocations[kCount];
};


}       // unnamed namespace


/*!     Returns the installation location relative path for the given base directory
        constant and installation location index. A '%' in the returned path must be
        replaced by "" for the primary architecture and by "/<arch>" for a secondary
        architecture.
 */
static const char*
get_relative_directory_path(size_t installationLocationIndex,
        path_base_directory baseDirectory)
{
        switch (baseDirectory) {
                case B_FIND_PATH_INSTALLATION_LOCATION_DIRECTORY:
                        return "";
                case B_FIND_PATH_ADD_ONS_DIRECTORY:
                        return "/add-ons%";
                case B_FIND_PATH_APPS_DIRECTORY:
                        return "/apps";
                case B_FIND_PATH_BIN_DIRECTORY:
                        return "/bin%";
                case B_FIND_PATH_BOOT_DIRECTORY:
                        return "/boot";
                case B_FIND_PATH_CACHE_DIRECTORY:
                        return "/cache";
                case B_FIND_PATH_DATA_DIRECTORY:
                        return "/data";
                case B_FIND_PATH_DEVELOP_DIRECTORY:
                        return "/develop";
                case B_FIND_PATH_DEVELOP_LIB_DIRECTORY:
                        return "/develop/lib%";
                case B_FIND_PATH_DOCUMENTATION_DIRECTORY:
                        return "/documentation";
                case B_FIND_PATH_ETC_DIRECTORY:
                        return "/settings/etc";
                case B_FIND_PATH_FONTS_DIRECTORY:
                        return "/data/fonts";
                case B_FIND_PATH_HEADERS_DIRECTORY:
                        return "/develop/headers%";
                case B_FIND_PATH_LIB_DIRECTORY:
                        return "/lib%";
                case B_FIND_PATH_LOG_DIRECTORY:
                        return "/log";
                case B_FIND_PATH_MEDIA_NODES_DIRECTORY:
                        return "/add-ons%/media";
                case B_FIND_PATH_PACKAGES_DIRECTORY:
                        return "/packages";
                case B_FIND_PATH_PREFERENCES_DIRECTORY:
                        return "/preferences";
                case B_FIND_PATH_SERVERS_DIRECTORY:
                        return "/servers";
                case B_FIND_PATH_SETTINGS_DIRECTORY:
                        return "/settings";
                case B_FIND_PATH_SOUNDS_DIRECTORY:
                        return "/data/sounds";
                case B_FIND_PATH_SPOOL_DIRECTORY:
                        return "/var/spool";
                case B_FIND_PATH_TRANSLATORS_DIRECTORY:
                        return "/add-ons%/Translators";
                case B_FIND_PATH_VAR_DIRECTORY:
                        return "/var";

                case B_FIND_PATH_IMAGE_PATH:
                case B_FIND_PATH_PACKAGE_PATH:
                default:
                        return NULL;
        }
}


static status_t
create_directory(char* path)
{
        // find the first directory that doesn't exist
        char* slash = path;
        bool found = false;
        while (!found && (slash = strchr(slash + 1, '/')) != NULL) {
                *slash = '\0';
                struct stat st;
                if (lstat(path, &st) != 0)
                        break;
                *slash = '/';
        }

        if (found)
                return B_OK;

        // create directories
        while (slash != NULL) {
                *slash = '\0';
                bool created = mkdir(path, 0755);
                *slash = '/';

                if (!created)
                        return errno;

                slash = strchr(slash + 1, '/');
        }

        return B_OK;
}


static bool
is_in_range(const void* pointer, const void* base, size_t size)
{
        return pointer >= base && (addr_t)pointer < (addr_t)base + size;
}


static status_t
find_image(const void* codePointer, image_info& _info)
{
        int32 cookie = 0;

        while (get_next_image_info(B_CURRENT_TEAM, &cookie, &_info) == B_OK) {
                if (codePointer == NULL ? _info.type == B_APP_IMAGE
                                : (is_in_range(codePointer, _info.text, _info.text_size)
                                        || is_in_range(codePointer, _info.data, _info.data_size))) {
                        return B_OK;
                }
        }

        return B_ENTRY_NOT_FOUND;
}


static status_t
copy_path(const char* path, char* buffer, size_t bufferSize)
{
        if (strlcpy(buffer, path, bufferSize) >= bufferSize)
                return B_BUFFER_OVERFLOW;
        return B_OK;
}


static status_t
normalize_path(const char* path, char* buffer, size_t bufferSize)
{
        status_t error;
        if (bufferSize >= B_PATH_NAME_LENGTH) {
                error = _kern_normalize_path(path, true, buffer);
        } else {
                char normalizedPath[B_PATH_NAME_LENGTH];
                error = _kern_normalize_path(path, true, normalizedPath);
                if (error == B_OK)
                        error = copy_path(path, buffer, bufferSize);
        }

        if (error != B_OK)
                return error;

        // make sure the path exists
        struct stat st;
        if (lstat(buffer, &st) != 0)
                return errno;

        return B_OK;
}


static status_t
normalize_longest_existing_path_prefix(const char* path, char* buffer,
        size_t bufferSize)
{
        if (strlcpy(buffer, path, bufferSize) >= bufferSize)
                return B_NAME_TOO_LONG;

        // Until we have an existing path, chop off leaf components.
        for (;;) {
                struct stat st;
                if (lstat(buffer, &st) == 0)
                        break;

                // Chop off the leaf, but fail, it it's "..", since then we'd actually
                // construct a subpath.
                char* lastSlash = strrchr(buffer, '/');
                if (lastSlash == NULL || strcmp(lastSlash + 1, "..") == 0)
                        return B_ENTRY_NOT_FOUND;

                *lastSlash = '\0';
        }

        // normalize the existing prefix path
        size_t prefixLength = strlen(buffer);
        status_t error = normalize_path(buffer, buffer, bufferSize);
        if (error != B_OK)
                return error;

        // Re-append the non-existent suffix. Remove duplicate slashes and "."
        // components.
        const char* bufferEnd = buffer + bufferSize;
        char* end = buffer + strlen(buffer);
        const char* remainder = path + prefixLength + 1;
        while (*remainder != '\0') {
                // find component start
                if (*remainder == '/') {
                        remainder++;
                        continue;
                }

                // find component end
                const char* componentEnd = strchr(remainder, '/');
                if (componentEnd == NULL)
                        componentEnd = remainder + strlen(remainder);

                // skip "." components
                size_t componentLength = componentEnd - remainder;
                if (componentLength == 1 && *remainder == '.') {
                        remainder++;
                        continue;
                }

                // append the component
                if (end + 1 + componentLength >= bufferEnd)
                        return B_BUFFER_OVERFLOW;

                *end++ = '/';
                memcpy(end, remainder, componentLength);
                end += componentLength;
                remainder += componentLength;
        }

        *end = '\0';
        return B_OK;
}


static status_t
get_file_attribute(const char* path, const char* attribute, char* nameBuffer,
        size_t bufferSize)
{
        int fd = fs_open_attr(path, attribute, B_STRING_TYPE,
                O_RDONLY | O_NOTRAVERSE);
        if (fd < 0)
                return errno;

        status_t error = B_OK;
        ssize_t bytesRead = read(fd, nameBuffer, bufferSize - 1);
        if (bytesRead < 0)
                error = bytesRead;
        else if (bytesRead == 0)
                error = B_ENTRY_NOT_FOUND;
        else
                nameBuffer[bytesRead] = '\0';

        fs_close_attr(fd);

        return error;
}


static status_t
normalize_dependency(const char* dependency, char* buffer, size_t bufferSize)
{
        if (strlcpy(buffer, dependency, bufferSize) >= bufferSize)
                return B_NAME_TOO_LONG;

        // replace all ':' with '~'
        char* colon = buffer - 1;
        while ((colon = strchr(colon + 1, ':')) != NULL)
                *colon = '~';

        return B_OK;
}


static ssize_t
process_path(const char* installationLocation, const char* architecture,
        const char* relativePath, const char* subPath, uint32 flags,
        char* pathBuffer, size_t bufferSize)
{
        // copy the installation location
        PathBuffer buffer(pathBuffer, bufferSize);
        buffer.Append(installationLocation);

        // append the relative path, expanding the architecture placeholder
        if (const char* placeholder = strchr(relativePath, '%')) {
                buffer.Append(relativePath, placeholder - relativePath);

                if (architecture != NULL) {
                        buffer.Append("/", 1);
                        buffer.Append(architecture);
                }

                buffer.Append(placeholder + 1);
        } else
                buffer.Append(relativePath);

        // append subpath, if given
        if (subPath != NULL) {
                buffer.Append("/", 1);
                buffer.Append(subPath);
        }

        size_t totalLength = buffer.Length();
        if (totalLength >= bufferSize)
                return B_BUFFER_OVERFLOW;

        // handle the flags
        char* path = pathBuffer;

        status_t error = B_OK;
        if ((flags & B_FIND_PATH_CREATE_DIRECTORY) != 0) {
                // create the directory
                error = create_directory(path);
        } else if ((flags & B_FIND_PATH_CREATE_PARENT_DIRECTORY) != 0) {
                // create the parent directory
                char* lastSlash = strrchr(path, '/');
                *lastSlash = '\0';
                error = create_directory(path);
                *lastSlash = '/';
        }

        if (error != B_OK)
                return error;

        if ((flags & B_FIND_PATH_EXISTING_ONLY) != 0) {
                // check if the entry exists
                struct stat st;
                if (lstat(path, &st) != 0)
                        return 0;
        }

        return totalLength + 1;
}


status_t
internal_path_for_path(char* referencePath, size_t referencePathSize,
        const char* dependency, const char* architecture,
        path_base_directory baseDirectory, const char* subPath, uint32 flags,
        char* pathBuffer, size_t bufferSize)
{
        if (strcmp(architecture, __get_primary_architecture()) == 0)
                architecture = NULL;

        // resolve dependency
        char packageName[B_FILE_NAME_LENGTH];
                // Temporarily used here, permanently used below where
                // B_FIND_PATH_PACKAGE_PATH is handled.
        if (dependency != NULL) {
                // get the versioned package name
                status_t error = get_file_attribute(referencePath, "SYS:PACKAGE",
                        packageName, sizeof(packageName));
                if (error != B_OK)
                        return error;

                // normalize the dependency name
                char normalizedDependency[B_FILE_NAME_LENGTH];
                error = normalize_dependency(dependency, normalizedDependency,
                        sizeof(normalizedDependency));
                if (error != B_OK)
                        return error;

                // Compute the path of the dependency symlink. This will yield the
                // installation location path when normalized.
                if (snprintf(referencePath, referencePathSize,
                                        kSystemPackageLinksDirectory "/%s/%s", packageName,
                                        normalizedDependency)
                                >= (ssize_t)referencePathSize) {
                        return B_BUFFER_OVERFLOW;
                }
        }

        // handle B_FIND_PATH_IMAGE_PATH
        if (baseDirectory == B_FIND_PATH_IMAGE_PATH)
                return copy_path(referencePath, pathBuffer, bufferSize);

        // Handle B_FIND_PATH_PACKAGE_PATH: get the package file name and
        // simply adjust our arguments to look the package file up in the packages
        // directory.
        if (baseDirectory == B_FIND_PATH_PACKAGE_PATH) {
                status_t error = get_file_attribute(referencePath, "SYS:PACKAGE_FILE",
                        packageName, sizeof(packageName));
                if (error != B_OK)
                        return error;

                dependency = NULL;
                subPath = packageName;
                baseDirectory = B_FIND_PATH_PACKAGES_DIRECTORY;
                flags = B_FIND_PATH_EXISTING_ONLY;
        }

        // normalize
        status_t error = normalize_path(referencePath, referencePath,
                referencePathSize);
        if (error != B_OK)
                return error;

        // get the installation location
        InstallationLocations* installationLocations = InstallationLocations::Get();
        MethodDeleter<InstallationLocations, void, &InstallationLocations::Put>
                installationLocationsDeleter(installationLocations);

        size_t installationLocationIndex;
        const char* installationLocation = installationLocations->LocationFor(
                referencePath, installationLocationIndex);
        if (installationLocation == NULL)
                return B_ENTRY_NOT_FOUND;

        // get base dir and process the path
        const char* relativePath = get_relative_directory_path(
                installationLocationIndex, baseDirectory);
        if (relativePath == NULL)
                return B_BAD_VALUE;

        ssize_t pathSize = process_path(installationLocation, architecture,
                relativePath, subPath, flags, pathBuffer, bufferSize);
        if (pathSize <= 0)
                return pathSize == 0 ? B_ENTRY_NOT_FOUND : pathSize;
        return B_OK;
}


// #pragma mark -


status_t
__find_path(const void* codePointer, path_base_directory baseDirectory,
        const char* subPath, char* pathBuffer, size_t bufferSize)
{
        return __find_path_etc(codePointer, NULL, NULL, baseDirectory, subPath, 0,
                pathBuffer, bufferSize);
}


status_t
__find_path_etc(const void* codePointer, const char* dependency,
        const char* architecture, path_base_directory baseDirectory,
        const char* subPath, uint32 flags, char* pathBuffer, size_t bufferSize)
{
        if (pathBuffer == NULL)
                return B_BAD_VALUE;

        // resolve codePointer to image info
        image_info imageInfo;
        status_t error = find_image(codePointer, imageInfo);
        if (error != B_OK)
                return error;

        if (architecture == NULL)
                architecture = __get_architecture();

        return internal_path_for_path(imageInfo.name, sizeof(imageInfo.name),
                dependency, architecture, baseDirectory, subPath, flags, pathBuffer,
                bufferSize);
}


status_t
__find_path_for_path(const char* path, path_base_directory baseDirectory,
        const char* subPath, char* pathBuffer, size_t bufferSize)
{
        return __find_path_for_path_etc(path, NULL, NULL, baseDirectory, subPath, 0,
                pathBuffer, bufferSize);
}


status_t
__find_path_for_path_etc(const char* path, const char* dependency,
        const char* architecture, path_base_directory baseDirectory,
        const char* subPath, uint32 flags, char* pathBuffer, size_t bufferSize)
{
        if (baseDirectory == B_FIND_PATH_IMAGE_PATH)
                return B_BAD_VALUE;

        char referencePath[B_PATH_NAME_LENGTH];
        if (strlcpy(referencePath, path, sizeof(referencePath))
                        >= sizeof(referencePath)) {
                return B_NAME_TOO_LONG;
        }

        if (architecture == NULL)
                architecture = __guess_architecture_for_path(path);

        return internal_path_for_path(referencePath, sizeof(referencePath),
                dependency, architecture, baseDirectory, subPath, flags, pathBuffer,
                bufferSize);
}


status_t
__find_paths(path_base_directory baseDirectory, const char* subPath,
        char*** _paths, size_t* _pathCount)
{
        return __find_paths_etc(NULL, baseDirectory, subPath, 0, _paths,
                _pathCount);
}


status_t
__find_paths_etc(const char* architecture, path_base_directory baseDirectory,
        const char* subPath, uint32 flags, char*** _paths, size_t* _pathCount)
{
        if (_paths == NULL || _pathCount == NULL)
                return B_BAD_VALUE;

        // Analyze architecture. If NULL, use the caller's architecture. If the
        // effective architecture is the primary one, set architecture to NULL to
        // indicate that we don't need to insert an architecture subdirectory
        // component.
        if (architecture == NULL)
                architecture = __get_architecture();
        if (strcmp(architecture, __get_primary_architecture()) == 0)
                architecture = NULL;
        size_t architectureSize = architecture != NULL
                ? strlen(architecture) + 1 : 0;

        size_t subPathLength = subPath != NULL ? strlen(subPath) + 1 : 0;

        // get the installation locations
        InstallationLocations* installationLocations = InstallationLocations::Get();
        MethodDeleter<InstallationLocations, void, &InstallationLocations::Put>
                installationLocationsDeleter(installationLocations);

        // Get the relative paths and compute the total size to allocate.
        const char* relativePaths[InstallationLocations::kCount];
        size_t totalSize = 0;

        for (size_t i = 0; i < InstallationLocations::kCount; i++) {
                if (((flags & B_FIND_PATHS_USER_ONLY) != 0
                                && !installationLocations->IsUserIndex(i))
                        || ((flags & B_FIND_PATHS_SYSTEM_ONLY) != 0
                                && !installationLocations->IsSystemIndex(i)))
                        continue;

                relativePaths[i] = get_relative_directory_path(i, baseDirectory);
                if (relativePaths[i] == NULL)
                        return B_BAD_VALUE;

                totalSize += strlen(installationLocations->At(i))
                        + strlen(relativePaths[i]) + subPathLength + 1;
                if (strchr(relativePaths[i], '%') != NULL)
                        totalSize += architectureSize - 1;
        }

        // allocate storage
        char** paths = (char**)malloc(sizeof(char*) * InstallationLocations::kCount
                + totalSize);
        if (paths == NULL)
                return B_NO_MEMORY;
        MemoryDeleter pathsDeleter(paths);

        // construct and process the paths
        size_t count = 0;
        char* pathBuffer = (char*)(paths + InstallationLocations::kCount);
        const char* pathBufferEnd = pathBuffer + totalSize;
        for (size_t i = 0; i < InstallationLocations::kCount; i++) {
                if (((flags & B_FIND_PATHS_USER_ONLY) != 0
                                && !installationLocations->IsUserIndex(i))
                        || ((flags & B_FIND_PATHS_SYSTEM_ONLY) != 0
                                && !installationLocations->IsSystemIndex(i)))
                        continue;

                ssize_t pathSize = process_path(installationLocations->At(i),
                        architecture, relativePaths[i], subPath, flags, pathBuffer,
                        pathBufferEnd - pathBuffer);
                if (pathSize < 0)
                        return pathSize;
                if (pathSize > 0) {
                        paths[count++] = pathBuffer;
                        pathBuffer += pathSize;
                }
        }

        if (count == 0)
                return B_ENTRY_NOT_FOUND;

        *_paths = paths;
        *_pathCount = count;
        pathsDeleter.Detach();

        return B_OK;
}


const char*
__guess_secondary_architecture_from_path(const char* path,
        const char* const* secondaryArchitectures,
        size_t secondaryArchitectureCount)
{
        // Get the longest existing prefix path and normalize it.
        char prefix[B_PATH_NAME_LENGTH];
        if (normalize_longest_existing_path_prefix(path, prefix, sizeof(prefix))
                        != B_OK) {
                return NULL;
        }

        // get an installation location relative path
        InstallationLocations* installationLocations = InstallationLocations::Get();
        MethodDeleter<InstallationLocations, void, &InstallationLocations::Put>
                installationLocationsDeleter(installationLocations);

        size_t installationLocationIndex;
        const char* installationLocation = installationLocations->LocationFor(
                prefix, installationLocationIndex);
        if (installationLocation == NULL)
                return NULL;

        const char* relativePath = prefix + strlen(installationLocation);
        if (relativePath[0] != '/')
                return NULL;

        // Iterate through the known paths that would indicate a secondary
        // architecture and try to match them with our given path.
        for (size_t i = 0; i < kArchitectureSpecificBaseDirectoryCount; i++) {
                const char* basePath = get_relative_directory_path(
                        installationLocationIndex, kArchitectureSpecificBaseDirectories[i]);
                const char* placeholder = strchr(basePath, '%');
                if (placeholder == NULL)
                        continue;

                // match the part up to the architecture placeholder
                size_t prefixLength = placeholder - basePath;
                if (strncmp(relativePath, basePath, prefixLength) != 0
                        || relativePath[prefixLength] != '/') {
                        continue;
                }

                // match the architecture
                const char* architecturePart = relativePath + prefixLength + 1;
                for (size_t k = 0; k < secondaryArchitectureCount; k++) {
                        const char* architecture = secondaryArchitectures[k];
                        size_t architectureLength = strlen(architecture);
                        if (strncmp(architecturePart, architecture, architectureLength) == 0
                                && (architecturePart[architectureLength] == '/'
                                        || architecturePart[architectureLength] == '\0')) {
                                return architecture;
                        }
                }
        }

        return NULL;
}


B_DEFINE_WEAK_ALIAS(__find_path, find_path);
B_DEFINE_WEAK_ALIAS(__find_path_etc, find_path_etc);
B_DEFINE_WEAK_ALIAS(__find_path_for_path, find_path_for_path);
B_DEFINE_WEAK_ALIAS(__find_path_for_path_etc, find_path_for_path_etc);
B_DEFINE_WEAK_ALIAS(__find_paths, find_paths);
B_DEFINE_WEAK_ALIAS(__find_paths_etc, find_paths_etc);