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


/*! A simple class wrapping a path. Has a fixed-sized buffer. */


#include <fs/KPath.h>
#include <Path.h>

#include <stdlib.h>
#include <string.h>

#include <team.h>


// debugging
#define TRACE(x) ;
//#define TRACE(x) dprintf x


KPath::KPath(size_t bufferSize)
        :
        fBuffer(NULL),
        fBufferSize(0),
        fPathLength(0),
        fLocked(false),
        fLazy(false),
        fFailed(false),
        fIsNull(false)
{
        SetTo(NULL, DEFAULT, bufferSize);
}


KPath::KPath(const char* path, int32 flags, size_t bufferSize)
        :
        fBuffer(NULL),
        fBufferSize(0),
        fPathLength(0),
        fLocked(false),
        fLazy(false),
        fFailed(false),
        fIsNull(false)
{
        SetTo(path, flags, bufferSize);
}


KPath::KPath(const KPath& other)
        :
        fBuffer(NULL),
        fBufferSize(0),
        fPathLength(0),
        fLocked(false),
        fLazy(false),
        fFailed(false),
        fIsNull(false)
{
        *this = other;
}


KPath::~KPath()
{
        free(fBuffer);
}


status_t
KPath::SetTo(const char* path, int32 flags, size_t bufferSize)
{
        if (bufferSize == 0)
                bufferSize = B_PATH_NAME_LENGTH;

        // free the previous buffer, if the buffer size differs
        if (fBuffer != NULL && fBufferSize != bufferSize) {
                free(fBuffer);
                fBuffer = NULL;
                fBufferSize = 0;
        }

        fPathLength = 0;
        fLocked = false;
        fBufferSize = bufferSize;
        fLazy = (flags & LAZY_ALLOC) != 0;
        fIsNull = path == NULL;

        if (path != NULL || !fLazy) {
                status_t status = _AllocateBuffer();
                if (status != B_OK)
                        return status;
        }

        return SetPath(path, flags);
}


void
KPath::Adopt(KPath& other)
{
        free(fBuffer);

        fBuffer = other.fBuffer;
        fBufferSize = other.fBufferSize;
        fPathLength = other.fPathLength;
        fLazy = other.fLazy;
        fFailed = other.fFailed;
        fIsNull = other.fIsNull;

        other.fBuffer = NULL;
        if (!other.fLazy)
                other.fBufferSize = 0;
        other.fPathLength = 0;
        other.fFailed = false;
        other.fIsNull = other.fLazy;
}


status_t
KPath::InitCheck() const
{
        if (fBuffer != NULL || (fLazy && !fFailed && fBufferSize != 0))
                return B_OK;

        return fFailed ? B_NO_MEMORY : B_NO_INIT;
}


/*!     \brief Sets the buffer to \a path.

        \param flags Understands the following two options:
                - \c NORMALIZE
                - \c TRAVERSE_LEAF_LINK
*/
status_t
KPath::SetPath(const char* path, int32 flags)
{
        if (path == NULL && fLazy && fBuffer == NULL) {
                fIsNull = true;
                return B_OK;
        }

        if (fBuffer == NULL) {
                if (fLazy) {
                        status_t status = _AllocateBuffer();
                        if (status != B_OK)
                                return B_NO_MEMORY;
                } else
                        return B_NO_INIT;
        }

        fIsNull = false;

        if (path != NULL) {
                if ((flags & NORMALIZE) != 0) {
                        // normalize path
                        status_t status = _Normalize(path,
                                (flags & TRAVERSE_LEAF_LINK) != 0);
                        if (status != B_OK)
                                return status;
                } else {
                        // don't normalize path
                        size_t length = strlen(path);
                        if (length >= fBufferSize)
                                return B_BUFFER_OVERFLOW;

                        memcpy(fBuffer, path, length + 1);
                        fPathLength = length;
                        _ChopTrailingSlashes();
                }
        } else {
                fBuffer[0] = '\0';
                fPathLength = 0;
                if (fLazy)
                        fIsNull = true;
        }
        return B_OK;
}


const char*
KPath::Path() const
{
        return fIsNull ? NULL : fBuffer;
}


/*!     \brief Locks the buffer for external changes.

        \param force In lazy mode, this will allocate a buffer when set.
                Otherwise, \c NULL will be returned if set to NULL.
*/
char*
KPath::LockBuffer(bool force)
{
        if (fBuffer == NULL && fLazy) {
                if (fIsNull && !force)
                        return NULL;

                _AllocateBuffer();
        }

        if (fBuffer == NULL || fLocked)
                return NULL;

        fLocked = true;
        fIsNull = false;

        return fBuffer;
}


void
KPath::UnlockBuffer()
{
        if (!fLocked) {
                TRACE(("KPath::UnlockBuffer(): ERROR: Buffer not locked!\n"));
                return;
        }

        fLocked = false;

        if (fBuffer == NULL)
                return;

        fPathLength = strnlen(fBuffer, fBufferSize);
        if (fPathLength == fBufferSize) {
                TRACE(("KPath::UnlockBuffer(): WARNING: Unterminated buffer!\n"));
                fPathLength--;
                fBuffer[fPathLength] = '\0';
        }
        _ChopTrailingSlashes();
}


char*
KPath::DetachBuffer()
{
        char* buffer = fBuffer;

        if (fBuffer != NULL) {
                fBuffer = NULL;
                fPathLength = 0;
                fLocked = false;
        }

        return buffer;
}


const char*
KPath::Leaf() const
{
        if (fBuffer == NULL)
                return NULL;

        for (int32 i = fPathLength - 1; i >= 0; i--) {
                if (fBuffer[i] == '/')
                        return fBuffer + i + 1;
        }

        return fBuffer;
}


status_t
KPath::ReplaceLeaf(const char* newLeaf)
{
        const char* leaf = Leaf();
        if (leaf == NULL)
                return B_NO_INIT;

        int32 leafIndex = leaf - fBuffer;
        // chop off the current leaf (don't replace "/", though)
        if (leafIndex != 0 || fBuffer[leafIndex - 1]) {
                fBuffer[leafIndex] = '\0';
                fPathLength = leafIndex;
                _ChopTrailingSlashes();
        }

        // if a leaf was given, append it
        if (newLeaf != NULL)
                return Append(newLeaf);
        return B_OK;
}


bool
KPath::RemoveLeaf()
{
        // get the leaf -- bail out, if not initialized or only the "/" is left
        const char* leaf = Leaf();
        if (leaf == NULL || leaf == fBuffer || leaf[0] == '\0')
                return false;

        // chop off the leaf
        int32 leafIndex = leaf - fBuffer;
        fBuffer[leafIndex] = '\0';
        fPathLength = leafIndex;
        _ChopTrailingSlashes();

        return true;
}


status_t
KPath::Append(const char* component, bool isComponent)
{
        // check initialization and parameter
        if (fBuffer == NULL)
                return B_NO_INIT;
        if (component == NULL)
                return B_BAD_VALUE;
        if (fPathLength == 0)
                return SetPath(component);

        // get component length
        size_t componentLength = strlen(component);
        if (componentLength < 1)
                return B_OK;

        // if our current path is empty, we just copy the supplied one
        // compute the result path len
        bool insertSlash = isComponent && fBuffer[fPathLength - 1] != '/'
                && component[0] != '/';
        size_t resultPathLength = fPathLength + componentLength
                + (insertSlash ? 1 : 0);
        if (resultPathLength >= fBufferSize)
                return B_BUFFER_OVERFLOW;

        // compose the result path
        if (insertSlash)
                fBuffer[fPathLength++] = '/';
        memcpy(fBuffer + fPathLength, component, componentLength + 1);
        fPathLength = resultPathLength;
        return B_OK;
}


status_t
KPath::Normalize(bool traverseLeafLink)
{
        if (fBuffer == NULL)
                return B_NO_INIT;
        if (fPathLength == 0)
                return B_BAD_VALUE;

        return _Normalize(fBuffer, traverseLeafLink);
}


KPath&
KPath::operator=(const KPath& other)
{
        SetTo(other.fBuffer, fLazy ? KPath::LAZY_ALLOC : KPath::DEFAULT,
                other.fBufferSize);
        return *this;
}


KPath&
KPath::operator=(const char* path)
{
        SetPath(path);
        return *this;
}


bool
KPath::operator==(const KPath& other) const
{
        if (fBuffer == NULL)
                return !other.fBuffer;

        return other.fBuffer != NULL
                && fPathLength == other.fPathLength
                && strcmp(fBuffer, other.fBuffer) == 0;
}


bool
KPath::operator==(const char* path) const
{
        if (fBuffer == NULL)
                return path == NULL;

        return path != NULL && strcmp(fBuffer, path) == 0;
}


bool
KPath::operator!=(const KPath& other) const
{
        return !(*this == other);
}


bool
KPath::operator!=(const char* path) const
{
        return !(*this == path);
}


status_t
KPath::_AllocateBuffer()
{
        if (fBuffer == NULL && fBufferSize != 0)
                fBuffer = (char*)malloc(fBufferSize);
        if (fBuffer == NULL) {
                fFailed = true;
                return B_NO_MEMORY;
        }

        fBuffer[0] = '\0';
        fFailed = false;
        return B_OK;
}


status_t
KPath::_Normalize(const char* path, bool traverseLeafLink)
{
        BPath normalizedPath;
        status_t error = normalizedPath.SetTo(path, NULL, true);
        if (error != B_OK) {
                fBuffer[0] = '\0';
                fPathLength = 0;
                return error;
        }

        strlcpy(fBuffer, normalizedPath.Path(), fBufferSize);
        fPathLength = strlen(fBuffer);
        return B_OK;
}


void
KPath::_ChopTrailingSlashes()
{
        if (fBuffer != NULL) {
                while (fPathLength > 1 && fBuffer[fPathLength - 1] == '/')
                        fBuffer[--fPathLength] = '\0';
        }
}