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


#include "AutoPackageAttributes.h"

#include <algorithm>
#include <new>

#include <TypeConstants.h>

#include <AutoDeleter.h>

#include "AttributeCookie.h"
#include "DebugSupport.h"
#include "Package.h"
#include "StringConstants.h"


class AutoPackageAttributeCookie : public AttributeCookie {
public:
        AutoPackageAttributeCookie(Package* package, AutoPackageAttribute attribute)
                :
                fPackage(package),
                fAttribute(attribute)
        {
                fPackage->AcquireReference();
        }

        virtual ~AutoPackageAttributeCookie()
        {
                fPackage->ReleaseReference();
        }

        virtual status_t ReadAttribute(off_t offset, void* buffer,
                size_t* bufferSize)
        {
                // get the attribute
                off_t size;
                uint32 type;
                const void* value = AutoPackageAttributes::GetAttributeValue(fPackage,
                        fAttribute, size, type);
                if (value == NULL)
                        return B_BAD_VALUE;

                // check and clamp offset and size
                if (offset < 0 || offset > size)
                        return B_BAD_VALUE;

                size_t toCopy = *bufferSize;
                if (offset + (off_t)toCopy > size)
                        toCopy = size - offset;

                if (toCopy > 0 && user_memcpy(buffer, (const uint8*)value + offset,
                        toCopy) < B_OK) {
                        return B_BAD_ADDRESS;
                }

                *bufferSize = toCopy;
                return B_OK;
        }

        virtual status_t ReadAttributeStat(struct stat* st)
        {
                if (AutoPackageAttributes::GetAttributeValue(fPackage, fAttribute,
                        st->st_size, st->st_type) == NULL) {
                        return B_BAD_VALUE;
                }

                return B_OK;
        }

private:
        Package*                                fPackage;
        AutoPackageAttribute    fAttribute;
};


/*static*/ bool
AutoPackageAttributes::AttributeForName(const StringKey& name,
        AutoPackageAttribute& _attribute)
{
        for (int i = 0; i < AUTO_PACKAGE_ATTRIBUTE_ENUM_COUNT; i++) {
                if (name == StringConstants::Get().kAutoPackageAttributeNames[i]) {
                        _attribute = (AutoPackageAttribute)i;
                        return true;
                }
        }

        return false;
}


/*static*/ const String&
AutoPackageAttributes::NameForAttribute(AutoPackageAttribute attribute)
{
        ASSERT(attribute >= 0 && attribute < AUTO_PACKAGE_ATTRIBUTE_ENUM_COUNT);
        return StringConstants::Get().kAutoPackageAttributeNames[attribute];
}


/*static*/ const void*
AutoPackageAttributes::GetAttributeValue(const Package* package,
        AutoPackageAttribute attribute, off_t& _size, uint32& _type)
{
        switch (attribute) {
                case AUTO_PACKAGE_ATTRIBUTE_PACKAGE:
                {
                        const char* value = package->VersionedName();
                        _size = strlen(value) + 1;
                        _type = B_STRING_TYPE;
                        return value;
                }

                case AUTO_PACKAGE_ATTRIBUTE_PACKAGE_FILE:
                {
                        const char* value = package->FileName();
                        _size = strlen(value) + 1;
                        _type = B_STRING_TYPE;
                        return value;
                }

                default:
                        return NULL;
        }
}


/*static*/ status_t
AutoPackageAttributes::OpenCookie(Package* package, const StringKey& name,
        int openMode, AttributeCookie*& _cookie)
{
        if (package == NULL)
                return B_ENTRY_NOT_FOUND;

        // get the attribute
        AutoPackageAttribute attribute;
        if (!AttributeForName(name, attribute))
                return B_ENTRY_NOT_FOUND;

        // allocate the cookie
        AutoPackageAttributeCookie* cookie = new(std::nothrow)
                AutoPackageAttributeCookie(package, attribute);
        if (cookie == NULL)
                RETURN_ERROR(B_NO_MEMORY);

        _cookie = cookie;
        return B_OK;
}