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


#include <boot/PathBlocklist.h>

#include <stdlib.h>

#include <algorithm>


// #pragma mark - BlockedPath


BlockedPath::BlockedPath()
        :
        fPath(NULL),
        fLength(0),
        fCapacity(0)
{
}


BlockedPath::~BlockedPath()
{
        free(fPath);
}


bool
BlockedPath::SetTo(const char* path)
{
        size_t length = strlen(path);
        if (length > 0 && path[length - 1] == '/')
                length--;

        if (!_Resize(length, false))
                return false;

        if (length > 0) {
                memcpy(fPath, path, length);
                fPath[length] = '\0';
        }

        return true;
}


bool
BlockedPath::Append(const char* component)
{
        size_t componentLength = strlen(component);
        if (componentLength > 0 && component[componentLength - 1] == '/')
                componentLength--;
        if (componentLength == 0)
                return true;

        size_t oldLength = fLength;
        size_t length = (fLength > 0 ? fLength + 1 : 0) + componentLength;
        if (!_Resize(length, true))
                return false;

        if (oldLength > 0)
                fPath[oldLength++] = '/';
        memcpy(fPath + oldLength, component, componentLength);
        return true;
}


bool
BlockedPath::_Resize(size_t length, bool keepData)
{
        if (length == 0) {
                free(fPath);
                fPath = NULL;
                fLength = 0;
                fCapacity = 0;
                return true;
        }

        if (length < fCapacity) {
                fPath[length] = '\0';
                fLength = length;
                return true;
        }

        size_t capacity = std::max(length + 1, 2 * fCapacity);
        capacity = std::max(capacity, size_t(32));

        char* path;
        if (fLength > 0 && keepData) {
                path = (char*)realloc(fPath, capacity);
                if (path == NULL)
                        return false;
        } else {
                path = (char*)malloc(capacity);
                if (path == NULL)
                        return false;
                free(fPath);
        }

        fPath = path;
        fPath[length] = '\0';
        fLength = length;
        fCapacity = capacity;
        return true;
}


// #pragma mark - PathBlocklist


PathBlocklist::PathBlocklist()
{
}


PathBlocklist::~PathBlocklist()
{
        MakeEmpty();
}


bool
PathBlocklist::Add(const char* path)
{
        BlockedPath* blockedPath = _FindPath(path);
        if (blockedPath != NULL)
                return true;

        blockedPath = new(std::nothrow) BlockedPath;
        if (blockedPath == NULL || !blockedPath->SetTo(path)) {
                delete blockedPath;
                return false;
        }

        fPaths.Add(blockedPath);
        return true;
}


void
PathBlocklist::Remove(const char* path)
{
        BlockedPath* blockedPath = _FindPath(path);
        if (blockedPath != NULL) {
                fPaths.Remove(blockedPath);
                delete blockedPath;
        }
}


bool
PathBlocklist::Contains(const char* path) const
{
        return _FindPath(path) != NULL;
}


void
PathBlocklist::MakeEmpty()
{
        while (BlockedPath* blockedPath = fPaths.RemoveHead())
                delete blockedPath;
}


BlockedPath*
PathBlocklist::_FindPath(const char* path) const
{
        for (PathList::ConstIterator it = fPaths.GetIterator(); it.HasNext();) {
                BlockedPath* blockedPath = it.Next();
                if (*blockedPath == path)
                        return blockedPath;
        }

        return NULL;
}