// AttributeDirectory.cpp

#include <new>

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

#include <AutoDeleter.h>
#include <Node.h>

#include "AttributeDirectory.h"

// small data size
static const int32 kSmallAttributeSize = 8;

// constructor
Attribute::Attribute(const char* name, const attr_info& info,
        const void* data)
        : fInfo(info)
{
        char* nameBuffer = fDataAndName;

        // copy data, if any
        if (data) {
                nameBuffer += info.size;
                memcpy(fDataAndName, data, info.size);

                // store a negative size to indicate we also have the data
                fInfo.size = -info.size;
        }

        // copy the name
        strcpy(nameBuffer, name);
}

// destructor
Attribute::~Attribute()
{
}

// CreateAttribute
status_t
Attribute::CreateAttribute(const char* name, const attr_info& info,
        const void* data, Attribute** attribute)
{
        if (!name || !attribute)
                return B_BAD_VALUE;

        // compute the size
        int32 nameLen = strlen(name);
        int32 size = sizeof(Attribute) + nameLen;
        if (data)
                size += info.size;

        void* buffer = malloc(size);
        if (!buffer)
                return B_NO_MEMORY;

        *attribute = new(buffer) Attribute(name, info, data);
        return B_OK;
}

// DeleteAttribute
void
Attribute::DeleteAttribute(Attribute* attribute)
{
        if (attribute) {
                attribute->~Attribute();
                free(attribute);
        }
}

// GetName
const char*
Attribute::GetName() const
{
        return (fInfo.size >= 0 ? fDataAndName : fDataAndName - fInfo.size);
}

// GetInfo
void
Attribute::GetInfo(attr_info* info) const
{
        if (info) {
                info->type = fInfo.type;
                info->size = GetSize();
        }
}

// GetType
uint32
Attribute::GetType() const
{
        return fInfo.type;
}

// GetSize
off_t
Attribute::GetSize() const
{
        return (fInfo.size >= 0 ? fInfo.size : -fInfo.size);
}

// GetData
const void*
Attribute::GetData() const
{
        return (fInfo.size >= 0 ? NULL : fDataAndName);
}


// #pragma mark -

// constructor
AttributeDirectory::AttributeDirectory()
        : fAttributes(),
          fStatus(ATTRIBUTE_DIRECTORY_NOT_LOADED)
{
}

// destructor
AttributeDirectory::~AttributeDirectory()
{
        ClearAttrDir();
}

// GetAttrDirStatus
uint32
AttributeDirectory::GetAttrDirStatus() const
{
        return fStatus;
}

// IsAttrDirValid
bool
AttributeDirectory::IsAttrDirValid() const
{
        return (fStatus == ATTRIBUTE_DIRECTORY_VALID);
}

// LoadAttrDir
status_t
AttributeDirectory::LoadAttrDir()
{
        // nothing to do, if already loaded
        if (fStatus == ATTRIBUTE_DIRECTORY_VALID)
                return B_OK;

        // if we tried earlier and the attr dir was too big, we fail again
        if (fStatus == ATTRIBUTE_DIRECTORY_TOO_BIG)
                return B_ERROR;

        // open the node
        BNode node;
        status_t error = OpenNode(node);
        if (error != B_OK)
                return error;

        // iterate through the attribute directory
        char name[B_ATTR_NAME_LENGTH];
        while (node.GetNextAttrName(name) == B_OK) {
                // get the attribute data
                attr_info info;
                char data[kSmallAttributeSize];
                bool dataLoaded = false;
                error = _LoadAttribute(node, name, info, data, dataLoaded);
                if (error != B_OK)
                        break;

                // create the attribute
                error = AddAttribute(name, info, (dataLoaded ? data : NULL));
        }

        if (error != B_OK)
                ClearAttrDir();
// TODO: Enforce maximum attribute directory size.

        return error;
}

// ClearAttrDir
void
AttributeDirectory::ClearAttrDir()
{
        while (Attribute* attribute = GetFirstAttribute())
                RemoveAttribute(attribute);
}

// AddAttribute
status_t
AttributeDirectory::AddAttribute(const char* name, const attr_info& info,
        const void* data)
{
        if (!name || GetAttribute(name))
                return B_BAD_VALUE;

        // create the attribute
        Attribute* attribute;
        status_t error = Attribute::CreateAttribute(name, info, data, &attribute);
        if (error != B_OK)
                return error;

        // add the attribute
        fAttributes.Insert(attribute);

        return B_OK;
}

// RemoveAttribute
bool
AttributeDirectory::RemoveAttribute(const char* name)
{
        if (!name)
                return false;

        for (SLList<Attribute>::Iterator it = fAttributes.GetIterator();
                 it.HasNext();) {
                Attribute* attribute = it.Next();
                if (strcmp(attribute->GetName(), name) == 0) {
                        it.Remove();
                        Attribute::DeleteAttribute(attribute);
                        return true;
                }
        }

        return false;
}

// RemoveAttribute
void
AttributeDirectory::RemoveAttribute(Attribute* attribute)
{
        if (!attribute)
                return;

        fAttributes.Remove(attribute);
        Attribute::DeleteAttribute(attribute);
}

// UpdateAttribute
status_t
AttributeDirectory::UpdateAttribute(const char* name, bool* removed,
        attr_info* _info, const void** _data)
{
        if (!name || !removed)
                return B_BAD_VALUE;

        // open the node
        BNode node;
        status_t error = OpenNode(node);
        if (error != B_OK) {
                ClearAttrDir();
                if (fStatus == ATTRIBUTE_DIRECTORY_VALID)
                        fStatus = ATTRIBUTE_DIRECTORY_NOT_LOADED;
                return error;
        }

        // get the attribute data
        attr_info info;
        char data[kSmallAttributeSize];
        bool dataLoaded = false;
        error = _LoadAttribute(node, name, info,
                (fStatus == ATTRIBUTE_DIRECTORY_VALID ? data : NULL), dataLoaded);
        if (error == B_OK) {
                if (fStatus == ATTRIBUTE_DIRECTORY_VALID) {
                        // remove the attribute
                        Attribute* previous = NULL;
                        for (SLList<Attribute>::Iterator it = fAttributes.GetIterator();
                                 it.HasNext();) {
                                Attribute* attribute = it.Next();
                                if (strcmp(attribute->GetName(), name) == 0) {
                                        it.Remove();
                                        Attribute::DeleteAttribute(attribute);
                                        break;
                                }
                                previous = attribute;
                        }

// TODO: Enforce the maximum attr dir size.
                        // re-create the attribute
                        Attribute* attribute;
                        error = Attribute::CreateAttribute(name, info, data,
                                &attribute);
                        if (error == B_OK) {
                                // add the attribute
                                fAttributes.InsertAfter(previous, attribute);

                                // return the desired info
                                if (_info)
                                        attribute->GetInfo(_info);
                                if (_data)
                                        *_data = attribute->GetData();
                                *removed = false;
                        }
                } else if (error == B_OK) {
                        if (_info)
                                *_info = info;
                        if (_data)
                                *_data = NULL;
                        *removed = false;
                }
        } else {
                *removed = true;
                RemoveAttribute(name);
                error = B_OK;
        }

        // clean up on error
        if (error != B_OK) {
                ClearAttrDir();
                if (fStatus == ATTRIBUTE_DIRECTORY_VALID)
                        fStatus = ATTRIBUTE_DIRECTORY_NOT_LOADED;
        }

        return error;
}

// GetAttribute
Attribute*
AttributeDirectory::GetAttribute(const char* name) const
{
        if (!name)
                return NULL;

        for (SLList<Attribute>::ConstIterator it = fAttributes.GetIterator();
                 it.HasNext();) {
                Attribute* attribute = it.Next();
                if (strcmp(attribute->GetName(), name) == 0)
                        return attribute;
        }

        return NULL;
}

// GetFirstAttribute
Attribute*
AttributeDirectory::GetFirstAttribute() const
{
        return fAttributes.GetFirst();
}

// GetNextAttribute
Attribute*
AttributeDirectory::GetNextAttribute(Attribute* attribute) const
{
        return (attribute ? fAttributes.GetNext(attribute) : NULL);
}

// _LoadAttribute
status_t
AttributeDirectory::_LoadAttribute(BNode& node, const char* name,
        attr_info& info, void* data, bool& dataLoaded)
{
        // stat the attribute
        status_t error = node.GetAttrInfo(name, &info);
        if (error != B_OK)
                return error;

        // if the data are small enough, read them
        if (data && info.size <= kSmallAttributeSize) {
                ssize_t bytesRead = node.ReadAttr(name, info.type, 0, data,
                        info.size);
                dataLoaded = (bytesRead == info.size);
        }

        return B_OK;
}