/*
 * Copyright 2013, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "FSUtils.h"

#include <string.h>

#include <algorithm>
#include <string>

#include <Directory.h>
#include <File.h>
#include <Path.h>
#include <SymLink.h>

#include <AutoDeleter.h>

#include "DebugSupport.h"


static const size_t kCompareDataBufferSize = 64 * 1024;
const char* const kShellEscapeCharacters = " ~`#$&*()\\|[]{};'\"<>?!";


/*static*/ BString
FSUtils::ShellEscapeString(const BString& string)
{
        BString result(string);
        result.CharacterEscape(kShellEscapeCharacters, '\\');
        if (result.IsEmpty())
                throw std::bad_alloc();
        return result;
}


/*static*/ status_t
FSUtils::OpenSubDirectory(const BDirectory& baseDirectory,
        const RelativePath& path, bool create, BDirectory& _directory)
{
        // get a string for the path
        BString pathString = path.ToString();
        if (pathString.IsEmpty())
                RETURN_ERROR(B_NO_MEMORY);

        // If creating is not allowed, just try to open it.
        if (!create)
                RETURN_ERROR(_directory.SetTo(&baseDirectory, pathString));

        // get an absolute path and create the subdirectory
        BPath absolutePath;
        status_t error = absolutePath.SetTo(&baseDirectory, pathString);
        if (error != B_OK) {
                ERROR("Volume::OpenSubDirectory(): failed to get absolute path "
                        "for subdirectory \"%s\": %s\n", pathString.String(),
                        strerror(error));
                RETURN_ERROR(error);
        }

        error = create_directory(absolutePath.Path(),
                S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
        if (error != B_OK) {
                ERROR("Volume::OpenSubDirectory(): failed to create "
                        "subdirectory \"%s\": %s\n", pathString.String(),
                        strerror(error));
                RETURN_ERROR(error);
        }

        RETURN_ERROR(_directory.SetTo(&baseDirectory, pathString));
}


/*static*/ status_t
FSUtils::CompareFileContent(const Entry& entry1, const Entry& entry2,
        bool& _equal)
{
        BFile file1;
        status_t error = _OpenFile(entry1, file1);
        if (error != B_OK)
                return error;

        BFile file2;
        error = _OpenFile(entry2, file2);
        if (error != B_OK)
                return error;

        return CompareFileContent(file1, file2, _equal);
}


/*static*/ status_t
FSUtils::CompareFileContent(BPositionIO& content1, BPositionIO& content2,
        bool& _equal)
{
        // get and compare content size
        off_t size1;
        status_t error = content1.GetSize(&size1);
        if (error != B_OK)
                return error;

        off_t size2;
        error = content2.GetSize(&size2);
        if (error != B_OK)
                return error;

        if (size1 != size2) {
                _equal = false;
                return B_OK;
        }

        if (size1 == 0) {
                _equal = true;
                return B_OK;
        }

        // allocate a data buffer
        uint8* buffer1 = new(std::nothrow) uint8[2 * kCompareDataBufferSize];
        if (buffer1 == NULL)
                return B_NO_MEMORY;
        ArrayDeleter<uint8> bufferDeleter(buffer1);
        uint8* buffer2 = buffer1 + kCompareDataBufferSize;

        // compare the data
        off_t offset = 0;
        while (offset < size1) {
                size_t toCompare = std::min(size_t(size1 - offset),
                        kCompareDataBufferSize);
                ssize_t bytesRead = content1.ReadAt(offset, buffer1, toCompare);
                if (bytesRead < 0)
                        return bytesRead;
                if ((size_t)bytesRead != toCompare)
                        return B_ERROR;

                bytesRead = content2.ReadAt(offset, buffer2, toCompare);
                if (bytesRead < 0)
                        return bytesRead;
                if ((size_t)bytesRead != toCompare)
                        return B_ERROR;

                if (memcmp(buffer1, buffer2, toCompare) != 0) {
                        _equal = false;
                        return B_OK;
                }

                offset += bytesRead;
        }

        _equal = true;
        return B_OK;
}


/*static*/ status_t
FSUtils::CompareSymLinks(const Entry& entry1, const Entry& entry2, bool& _equal)
{
        BSymLink symLink1;
        status_t error = _OpenSymLink(entry1, symLink1);
        if (error != B_OK)
                return error;

        BSymLink symLink2;
        error = _OpenSymLink(entry2, symLink2);
        if (error != B_OK)
                return error;

        return CompareSymLinks(symLink1, symLink2, _equal);
}


/*static*/ status_t
FSUtils::CompareSymLinks(BSymLink& symLink1, BSymLink& symLink2, bool& _equal)
{
        char buffer1[B_PATH_NAME_LENGTH];
        ssize_t bytesRead1 = symLink1.ReadLink(buffer1, sizeof(buffer1));
        if (bytesRead1 < 0)
                return bytesRead1;

        char buffer2[B_PATH_NAME_LENGTH];
        ssize_t bytesRead2 = symLink2.ReadLink(buffer2, sizeof(buffer2));
        if (bytesRead2 < 0)
                return bytesRead2;

        _equal = bytesRead1 == bytesRead2
                && memcmp(buffer1, buffer2, bytesRead1) == 0;
        return B_OK;
}


/*static*/ status_t
FSUtils::ExtractPackageContent(const Entry& packageEntry,
        const char* contentPath, const Entry& targetDirectoryEntry)
{
        BPath packagePathBuffer;
        const char* packagePath;
        status_t error = packageEntry.GetPath(packagePathBuffer, packagePath);
        if (error != B_OK)
                return error;

        BPath targetPathBuffer;
        const char* targetPath;
        error = targetDirectoryEntry.GetPath(targetPathBuffer, targetPath);
        if (error != B_OK)
                return error;

        return ExtractPackageContent(packagePath, contentPath, targetPath);
}


/*static*/ status_t
FSUtils::ExtractPackageContent(const char* packagePath, const char* contentPath,
        const char* targetDirectoryPath)
{
        std::string commandLine = std::string("package extract -C ")
                + ShellEscapeString(targetDirectoryPath).String()
                + " "
                + ShellEscapeString(packagePath).String()
                + " "
                + ShellEscapeString(contentPath).String();
        if (system(commandLine.c_str()) != 0)
                return B_ERROR;
        return B_OK;
}


/*static*/ status_t
FSUtils::_OpenFile(const Entry& entry, BFile& file)
{
        BPath pathBuffer;
        const char* path;
        status_t error = entry.GetPath(pathBuffer, path);
        if (error != B_OK)
                return error;

        return file.SetTo(path, B_READ_ONLY);
}


/*static*/ status_t
FSUtils::_OpenSymLink(const Entry& entry, BSymLink& symLink)
{
        BPath pathBuffer;
        const char* path;
        status_t error = entry.GetPath(pathBuffer, path);
        if (error != B_OK)
                return error;

        return symLink.SetTo(path);
}