// ShareAttrDir.cpp

#include <new>

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

#include <Node.h>

#include "AttrDirInfo.h"
#include "AutoDeleter.h"
#include "ShareAttrDir.h"

// compare_attributes
//
// NULL is considered the maximum
static
int
compare_attributes(const Attribute* a, const Attribute* b)
{
	if (a == b)
		return 0;
	if (!a)
		return 1;
	if (!b)
		return -1;

	return strcmp(a->GetName(), b->GetName());
}

// compare_attributes
static
int
compare_attributes(const void* _a, const void* _b)
{
	return compare_attributes(*(const Attribute**)_a, *(const Attribute**)_b);
}

// compare_iterators
static
int
compare_iterators(const ShareAttrDirIterator* a, const ShareAttrDirIterator* b)
{
	return compare_attributes(a->GetCurrentAttribute(),
		b->GetCurrentAttribute());
}

// compare_iterators
static
int
compare_iterators(const void* _a, const void* _b)
{
	return compare_iterators(*(const ShareAttrDirIterator**)_a,
		*(const ShareAttrDirIterator**)_b);
}

// 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
ShareAttrDir::ShareAttrDir()
	: fAttributes(),
	  fRevision(-1),
	  fUpToDate(false)
{
}

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

// Init
status_t
ShareAttrDir::Init(const AttrDirInfo& dirInfo)
{
	if (!dirInfo.isValid)
		return B_BAD_VALUE;

	// get the attributes
	Attribute** attributes = NULL;
	int32 count = 0;
	status_t error = _GetAttributes(dirInfo, attributes, count);
	if (error != B_OK)
		return error;
	ArrayDeleter<Attribute*> _(attributes);

	// add the attributes
	for (int32 i = 0; i < count; i++)
		fAttributes.Insert(attributes[i]);

	fRevision = dirInfo.revision;
	fUpToDate = true;

	return B_OK;
}

// Update
status_t
ShareAttrDir::Update(const AttrDirInfo& dirInfo,
	DoublyLinkedList<ShareAttrDirIterator>* iterators)
{
	if (!dirInfo.isValid)
		return B_BAD_VALUE;

	if (fRevision >= dirInfo.revision)
		return B_OK;

	// allocate an array for the old attributes
	int32 oldCount = fAttributes.Size();
	Attribute** oldAttributes = new(std::nothrow) Attribute*[oldCount];
	if (!oldAttributes)
		return B_NO_MEMORY;
	ArrayDeleter<Attribute*> _(oldAttributes);

	// get the new attributes
	Attribute** newAttributes = NULL;
	int32 newCount = 0;
	status_t error = _GetAttributes(dirInfo, newAttributes, newCount);
	if (error != B_OK)
		return error;
	ArrayDeleter<Attribute*> _2(newAttributes);

	// sort the iterators
	int32 iteratorCount = (iterators ? iterators->Count() : 0);
	if (iteratorCount > 0) {
		// allocate an array
		ShareAttrDirIterator** _iterators
			= new(std::nothrow) ShareAttrDirIterator*[iteratorCount];
		if (!_iterators)
			return B_NO_MEMORY;
		ArrayDeleter<ShareAttrDirIterator*> _3(_iterators);

		// move the iterators
		for (int32 i = 0; i < iteratorCount; i++) {
			ShareAttrDirIterator* iterator = iterators->First();
			_iterators[i] = iterator;
			iterators->Remove(iterator);
		}

		// sort them
		qsort(_iterators, iteratorCount, sizeof(ShareAttrDirIterator*),
			compare_iterators);

		// move them back into the list
		for (int32 i = 0; i < iteratorCount; i++)
			iterators->Insert(_iterators[i]);
	}

	// remove the old attributes
	for (int32 i = 0; i < oldCount; i++) {
		Attribute* attribute = fAttributes.GetFirst();
		oldAttributes[i] = attribute;
		fAttributes.Remove(attribute);
	}

	// add the new attributes
	int32 oldIndex = 0;
	int32 newIndex = 0;
	ShareAttrDirIterator* iterator = (iterators ? iterators->First() : NULL);
	while (oldIndex < oldCount || newIndex < newCount) {
		Attribute* oldAttr = (oldCount > 0 ? oldAttributes[oldIndex] : NULL);
		Attribute* newAttr = (newCount > 0 ? newAttributes[newIndex] : NULL);
		int cmp = compare_attributes(oldAttr, newAttr);
		if (cmp < 0) {
			// oldAttr is obsolete: move all iterators pointing to it to the
			// next new attribute
			while (iterator && iterator->GetCurrentAttribute() == oldAttr) {
				iterator->SetCurrentAttribute(newAttr);
				iterator = iterators->GetNext(iterator);
			}
			oldIndex++;
		} else if (cmp > 0) {
			// newAttr is new
			fAttributes.Insert(newAttr);
			newIndex++;
		} else {
			// oldAttr == newAttr
			fAttributes.Insert(newAttr);
			oldIndex++;
			newIndex++;

			// move the attributes pointing to this attribute
			while (iterator && iterator->GetCurrentAttribute() == oldAttr) {
				iterator->SetCurrentAttribute(newAttr);
				iterator = iterators->GetNext(iterator);
			}
		}
	}

	// delete the old attributes
	for (int32 i = 0; i < oldCount; i++)
		Attribute::DeleteAttribute(oldAttributes[i]);

	fRevision = dirInfo.revision;
	fUpToDate = true;

	return B_OK;
}

// SetRevision
void
ShareAttrDir::SetRevision(int64 revision)
{
	fRevision = revision;
}

// GetRevision
int64
ShareAttrDir::GetRevision() const
{
	return fRevision;
}

// SetUpToDate
void
ShareAttrDir::SetUpToDate(bool upToDate)
{
	fUpToDate = upToDate;
}

// IsUpToDate
bool
ShareAttrDir::IsUpToDate() const
{
	return fUpToDate;
}

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

// AddAttribute
status_t
ShareAttrDir::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
ShareAttrDir::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
ShareAttrDir::RemoveAttribute(Attribute* attribute)
{
	if (!attribute)
		return;

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

// GetAttribute
Attribute*
ShareAttrDir::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*
ShareAttrDir::GetFirstAttribute() const
{
	return fAttributes.GetFirst();
}

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

// _GetAttributes
status_t
ShareAttrDir::_GetAttributes(const AttrDirInfo& dirInfo,
	Attribute**& _attributes, int32& _count)
{
	if (!dirInfo.isValid)
		return B_BAD_VALUE;

	int32 count = dirInfo.attributeInfos.CountElements();
	const AttributeInfo* attrInfos = dirInfo.attributeInfos.GetElements();

	// allocate an attribute array
	Attribute** attributes = NULL;
	if (count > 0) {
		attributes = new(std::nothrow) Attribute*[count];
		if (!attributes)
			return B_NO_MEMORY;
		memset(attributes, 0, sizeof(Attribute*) * count);
	}

	status_t error = B_OK;
	for (int32 i = 0; i < count; i++) {
		const AttributeInfo& attrInfo = attrInfos[i];

		// create the attribute
		const void* data = attrInfo.data.GetData();
		if (data && attrInfo.data.GetSize() != attrInfo.info.size)
			data = NULL;
		error = Attribute::CreateAttribute(attrInfo.name.GetString(),
			attrInfo.info, data, attributes + i);
		if (error != B_OK)
			break;
	}

	// cleanup on error
	if (error != B_OK) {
		for (int32 i = 0; i < count; i++) {
			if (Attribute* attribute = attributes[i])
				Attribute::DeleteAttribute(attribute);
		}
		delete[] attributes;

		return error;
	}

	// sort the attribute array
	if (count > 0)
		qsort(attributes, count, sizeof(Attribute*), compare_attributes);

	_attributes = attributes;
	_count = count;
	return B_OK;
}