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


#include <new>

#include <String.h>

#include <EntryOperationEngineBase.h>


class BDirectory;
class BFile;
class BPositionIO;
class BSymLink;


class FSUtils {
public:
        typedef ::BPrivate::BEntryOperationEngineBase::Entry Entry;

public:
        struct RelativePath {
                RelativePath(const char* component1 = NULL,
                        const char* component2 = NULL, const char* component3 = NULL)
                        :
                        fComponentCount(kMaxComponentCount)
                {
                        fComponents[0] = component1;
                        fComponents[1] = component2;
                        fComponents[2] = component3;

                        for (size_t i = 0; i < kMaxComponentCount; i++) {
                                if (fComponents[i] == NULL) {
                                        fComponentCount = i;
                                        break;
                                }
                        }
                }

                bool IsEmpty() const
                {
                        return fComponentCount == 0;
                }

                RelativePath HeadPath(size_t componentsToDropCount = 1)
                {
                        RelativePath result;
                        if (componentsToDropCount < fComponentCount) {
                                result.fComponentCount
                                        = fComponentCount - componentsToDropCount;
                                for (size_t i = 0; i < result.fComponentCount; i++)
                                        result.fComponents[i] = fComponents[i];
                        }

                        return result;
                }

                const char* LastComponent() const
                {
                        return fComponentCount > 0
                                ? fComponents[fComponentCount - 1] : NULL;
                }

                BString ToString() const
                {
                        if (fComponentCount == 0)
                                return BString();

                        size_t length = fComponentCount - 1;
                        for (size_t i = 0; i < fComponentCount; i++)
                                length += strlen(fComponents[i]);

                        BString result;
                        char* buffer = result.LockBuffer(length + 1);
                        if (buffer == NULL)
                                return BString();

                        for (size_t i = 0; i < fComponentCount; i++) {
                                if (i > 0) {
                                        *buffer = '/';
                                        buffer++;
                                }
                                strcpy(buffer, fComponents[i]);
                                buffer += strlen(buffer);
                        }

                        return result.UnlockBuffer();
                }

        private:
                static const size_t     kMaxComponentCount = 3;

                const char*     fComponents[kMaxComponentCount];
                size_t          fComponentCount;
        };

        // throwing std::bad_alloc()
        class Path {
        public:
                Path(const char* path)
                        :
                        fPath(path)
                {
                        if (fPath.IsEmpty()) {
                                if (path[0] != '\0')
                                        throw std::bad_alloc();
                        } else {
                                // remove duplicate '/'s
                                char* buffer = fPath.LockBuffer(fPath.Length());
                                int32 k = 0;
                                for (int32 i = 0; buffer[i] != '\0'; i++) {
                                        if (buffer[i] == '/' && k > 0 && buffer[k - 1] == '/')
                                                continue;
                                        buffer[k++] = buffer[i];
                                }

                                // remove trailing '/'
                                if (k > 1 && buffer[k - 1] == '/')
                                        k--;

                                fPath.LockBuffer(k);
                        }
                }

                Path& AppendComponent(const char* component)
                {
                        if (fPath.IsEmpty()) {
                                fPath = component;
                                if (fPath.IsEmpty() && component[0] != '\0')
                                        throw std::bad_alloc();
                        } else {
                                int32 length = fPath.Length();
                                if (fPath[length - 1] != '/') {
                                        fPath += '/';
                                        if (++length != fPath.Length())
                                                throw std::bad_alloc();
                                }

                                fPath += component;
                                if (fPath.Length() <= length)
                                        throw std::bad_alloc();
                        }

                        return *this;
                }

                Path& RemoveLastComponent()
                {
                        int32 index = fPath.FindLast('/');
                        if (index < 0 || (index == 0 && fPath.Length() == 1))
                                fPath.Truncate(0);
                        else if (index == 0)
                                fPath.Truncate(1);
                        else
                                fPath.Truncate(index);
                        return *this;
                }

                const char* Leaf() const
                {
                        int32 index = fPath.FindLast('/');
                        if (index < 0 || (index == 0 && fPath.Length() == 1))
                                return fPath.String();
                        return fPath.String() + index + 1;
                }

                const BString ToString() const
                {
                        return fPath;
                }

                const char* ToCString() const
                {
                        return fPath.String();
                }

                operator const BString&() const
                {
                        return fPath;
                }

                operator const char*() const
                {
                        return fPath;
                }

        private:
                BString fPath;
        };

public:
        static  BString                         ShellEscapeString(const BString& string);
                                                                        // throw std::bad_alloc

        static  status_t                        OpenSubDirectory(
                                                                        const BDirectory& baseDirectory,
                                                                        const RelativePath& path, bool create,
                                                                        BDirectory& _directory);

        static  status_t                        CompareFileContent(const Entry& entry1,
                                                                        const Entry& entry2, bool& _equal);
        static  status_t                        CompareFileContent(BPositionIO& content1,
                                                                        BPositionIO& content2, bool& _equal);

        static  status_t                        CompareSymLinks(const Entry& entry1,
                                                                        const Entry& entry2, bool& _equal);
        static  status_t                        CompareSymLinks(BSymLink& symLink1,
                                                                        BSymLink& symLink2, bool& _equal);

        static  status_t                        ExtractPackageContent(const Entry& packageEntry,
                                                                        const char* contentPath,
                                                                        const Entry& targetDirectoryEntry);
        static  status_t                        ExtractPackageContent(const char* packagePath,
                                                                        const char* contentPath,
                                                                        const char* targetDirectoryPath);

private:
        static  status_t                        _OpenFile(const Entry& entry, BFile& file);
        static  status_t                        _OpenSymLink(const Entry& entry,
                                                                        BSymLink& symLink);
};



#endif  // FS_UTILS_H