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


#include <EntryOperationEngineBase.h>

#include <Directory.h>
#include <Entry.h>
#include <Path.h>


namespace BPrivate {


BEntryOperationEngineBase::Entry::Entry(const char* path)
        :
        fDirectory(NULL),
        fPath(path),
        fEntry(NULL),
        fEntryRef(NULL),
        fDirectoryRef(NULL)
{
}


BEntryOperationEngineBase::Entry::Entry(const BDirectory& directory,
        const char* path)
        :
        fDirectory(&directory),
        fPath(path),
        fEntry(NULL),
        fEntryRef(NULL),
        fDirectoryRef(NULL)
{
}


BEntryOperationEngineBase::Entry::Entry(const BEntry& entry)
        :
        fDirectory(NULL),
        fPath(NULL),
        fEntry(&entry),
        fEntryRef(NULL),
        fDirectoryRef(NULL)
{
}


BEntryOperationEngineBase::Entry::Entry(const entry_ref& entryRef)
        :
        fDirectory(NULL),
        fPath(NULL),
        fEntry(NULL),
        fEntryRef(&entryRef),
        fDirectoryRef(NULL)
{
}


BEntryOperationEngineBase::Entry::Entry(const node_ref& directoryRef,
        const char* path)
        :
        fDirectory(NULL),
        fPath(path),
        fEntry(NULL),
        fEntryRef(NULL),
        fDirectoryRef(&directoryRef)
{
}


BEntryOperationEngineBase::Entry::~Entry()
{
}


status_t
BEntryOperationEngineBase::Entry::GetPath(BPath& buffer, const char*& _path)
        const
{
        status_t error = B_OK;

        if (fEntry != NULL) {
                error = buffer.SetTo(fEntry);
        } else if (fDirectory != NULL) {
                error = buffer.SetTo(fDirectory, fPath);
        } else if (fEntryRef != NULL) {
                error = buffer.SetTo(fEntryRef);
        } else if (fDirectoryRef != NULL) {
                BDirectory directory;
                error = directory.SetTo(fDirectoryRef);
                if (error == B_OK)
                        error = buffer.SetTo(&directory, fPath);
        } else if (fPath != NULL) {
                _path = fPath;
                return B_OK;
        }

        if (error != B_OK)
                return error;

        _path = buffer.Path();
        return B_OK;
}


BString
BEntryOperationEngineBase::Entry::Path() const
{
        BPath pathBuffer;
        const char* path;
        if (GetPath(pathBuffer, path) == B_OK)
                return BString(path);
        return BString();
}


status_t
BEntryOperationEngineBase::Entry::GetPathOrName(BString& _path) const
{
        _path.Truncate(0);

        BPath buffer;
        const char* path;
        status_t error = GetPath(buffer, path);
        if (error == B_NO_MEMORY)
                return error;

        if (error == B_OK) {
                _path = path;
        } else if (fEntry != NULL) {
                // GetPath() apparently failed, so just return the entry name.
                _path = fEntry->Name();
        } else if (fDirectory != NULL || fDirectoryRef != NULL) {
                if (fPath != NULL && fPath[0] == '/') {
                        // absolute path -- just return it
                        _path = fPath;
                } else {
                        // get the directory path
                        BEntry entry;
                        if (fDirectory != NULL) {
                                error = fDirectory->GetEntry(&entry);
                        } else {
                                BDirectory directory;
                                error = directory.SetTo(fDirectoryRef);
                                if (error == B_OK)
                                        error = directory.GetEntry(&entry);
                        }

                        if (error != B_OK || (error = entry.GetPath(&buffer)) != B_OK)
                                return error;

                        _path = buffer.Path();

                        // If we additionally have a relative path, append it.
                        if (!_path.IsEmpty() && fPath != NULL) {
                                int32 length = _path.Length();
                                _path << '/' << fPath;
                                if (_path.Length() < length + 2)
                                        return B_NO_MEMORY;
                        }
                }
        } else if (fEntryRef != NULL) {
                // Getting the actual path apparently failed, so just return the entry
                // name.
                _path = fEntryRef->name;
        } else if (fPath != NULL)
                _path = fPath;

        return _path.IsEmpty() ? B_NO_MEMORY : B_OK;
}


BString
BEntryOperationEngineBase::Entry::PathOrName() const
{
        BString path;
        return GetPathOrName(path) == B_OK ? path : BString();
}


} // namespace BPrivate