//----------------------------------------------------------------------
//  This software is part of the Haiku distribution and is covered
//  by the MIT License.
//---------------------------------------------------------------------

#include <stdio.h>
#include <string.h>

#include <new>

#include <disk_device_manager.h>
#include <PartitioningInfo.h>

#include <syscalls.h>
#include <ddm_userland_interface_defs.h>


using namespace std;


//#define TRACING 1
#if TRACING
#  define TRACE(x) printf x
#else
#  define TRACE(x)
#endif


// constructor
BPartitioningInfo::BPartitioningInfo()
	:
	fPartitionID(-1),
	fSpaces(NULL),
	fCount(0),
	fCapacity(0)
{
}


// destructor
BPartitioningInfo::~BPartitioningInfo()
{
	Unset();
}


// SetTo
status_t
BPartitioningInfo::SetTo(off_t offset, off_t size)
{
	TRACE(("%p - BPartitioningInfo::SetTo(offset = %lld, size = %lld)\n", this, offset, size));

	fPartitionID = -1;
	delete[] fSpaces;

	if (size > 0) {
		fSpaces = new(nothrow) partitionable_space_data[1];
		if (!fSpaces)
			return B_NO_MEMORY;

		fCount = 1;
		fSpaces[0].offset = offset;
		fSpaces[0].size = size;
	} else {
		fSpaces = NULL;
		fCount = 0;
	}

	fCapacity = fCount;

	return B_OK;
}


// Unset
void
BPartitioningInfo::Unset()
{
	delete[] fSpaces;
	fPartitionID = -1;
	fSpaces = NULL;
	fCount = 0;
	fCapacity = 0;
}


// ExcludeOccupiedSpace
status_t
BPartitioningInfo::ExcludeOccupiedSpace(off_t offset, off_t size)
{
	if (size <= 0)
		return B_OK;

	TRACE(("%p - BPartitioningInfo::ExcludeOccupiedSpace(offset = %lld, "
		"size = %lld)\n", this, offset, size));

	int32 leftIndex = -1;
	int32 rightIndex = -1;
	for (int32 i = 0; i < fCount; i++) {
		if (leftIndex == -1
			&& offset < fSpaces[i].offset + fSpaces[i].size) {
			leftIndex = i;
		}

		if (fSpaces[i].offset < offset + size)
			rightIndex = i;
	}

	TRACE(("  leftIndex = %ld, rightIndex = %ld\n", leftIndex, rightIndex));

	// If there's no intersection with any free space, we're done.
	if (leftIndex == -1 || rightIndex == -1 || leftIndex > rightIndex)
		return B_OK;

	partitionable_space_data& leftSpace = fSpaces[leftIndex];
	partitionable_space_data& rightSpace = fSpaces[rightIndex];

	off_t rightSpaceEnd = rightSpace.offset + rightSpace.size;

	// special case: split a single space in two
	if (leftIndex == rightIndex && leftSpace.offset < offset
		&& rightSpaceEnd > offset + size) {

		TRACE(("  splitting space at %ld\n", leftIndex));

		// add a space after this one
		status_t error = _InsertSpaces(leftIndex + 1, 1);
		if (error != B_OK)
			return error;

		// IMPORTANT: after calling _InsertSpace(), one can not
		// use the partitionable_space_data references "leftSpace"
		// and "rightSpace" anymore (declared above)!

		partitionable_space_data& space = fSpaces[leftIndex];
		partitionable_space_data& newSpace = fSpaces[leftIndex + 1];

		space.size = offset - space.offset;

		newSpace.offset = offset + size;
		newSpace.size = rightSpaceEnd - newSpace.offset;

		#ifdef TRACING
			PrintToStream();
		#endif
		return B_OK;
	}

	// check whether the first affected space is eaten completely
	int32 deleteFirst = leftIndex;
	if (leftSpace.offset < offset) {
		leftSpace.size = offset - leftSpace.offset;

		TRACE(("  left space remains, new size is %lld\n", leftSpace.size));

		deleteFirst++;
	}

	// check whether the last affected space is eaten completely
	int32 deleteLast = rightIndex;
	if (rightSpaceEnd > offset + size) {
		rightSpace.offset = offset + size;
		rightSpace.size = rightSpaceEnd - rightSpace.offset;

		TRACE(("  right space remains, new offset = %lld, size = %lld\n",
			rightSpace.offset, rightSpace.size));

		deleteLast--;
	}

	// remove all spaces that are completely eaten
	if (deleteFirst <= deleteLast)
		_RemoveSpaces(deleteFirst, deleteLast - deleteFirst + 1);

	#ifdef TRACING
		PrintToStream();
	#endif
	return B_OK;
}


// PartitionID
partition_id
BPartitioningInfo::PartitionID() const
{
	return fPartitionID;
}


// GetPartitionableSpaceAt
status_t
BPartitioningInfo::GetPartitionableSpaceAt(int32 index, off_t* offset,
										   off_t *size) const
{
	if (!fSpaces)
		return B_NO_INIT;
	if (!offset || !size)
		return B_BAD_VALUE;
	if (index < 0 || index >= fCount)
		return B_BAD_INDEX;
	*offset = fSpaces[index].offset;
	*size = fSpaces[index].size;
	return B_OK;
}


// CountPartitionableSpaces
int32
BPartitioningInfo::CountPartitionableSpaces() const
{
	return fCount;
}


// PrintToStream
void
BPartitioningInfo::PrintToStream() const
{
	if (!fSpaces) {
		printf("BPartitioningInfo is not initialized\n");
		return;
	}
	printf("BPartitioningInfo has %" B_PRId32 " spaces:\n", fCount);
	for (int32 i = 0; i < fCount; i++) {
		printf("  space at %" B_PRId32 ": offset = %" B_PRId64 ", size = %"
			B_PRId64 "\n", i, fSpaces[i].offset, fSpaces[i].size);
	}
}


// #pragma mark -


// _InsertSpaces
status_t
BPartitioningInfo::_InsertSpaces(int32 index, int32 count)
{
	if (index <= 0 || index > fCount || count <= 0)
		return B_BAD_VALUE;

	// If the capacity is sufficient, we just need to copy the spaces to create
	// a gap.
	if (fCount + count <= fCapacity) {
		memmove(fSpaces + index + count, fSpaces + index,
			(fCount - index) * sizeof(partitionable_space_data));
		fCount += count;
		return B_OK;
	}

	// alloc new array
	int32 capacity = (fCount + count) * 2;
		// add a bit room for further resizing

	partitionable_space_data* spaces
		= new(nothrow) partitionable_space_data[capacity];
	if (!spaces)
		return B_NO_MEMORY;

	// copy items
	memcpy(spaces, fSpaces, index * sizeof(partitionable_space_data));
	memcpy(spaces + index + count, fSpaces + index,
		(fCount - index) * sizeof(partitionable_space_data));

	delete[] fSpaces;
	fSpaces = spaces;
	fCapacity = capacity;
	fCount += count;

	return B_OK;
}


// _RemoveSpaces
void
BPartitioningInfo::_RemoveSpaces(int32 index, int32 count)
{
	if (index < 0 || count <= 0 || index + count > fCount)
		return;

	if (count < fCount) {
		int32 endIndex = index + count;
		memmove(fSpaces + index, fSpaces + endIndex,
			(fCount - endIndex) * sizeof(partitionable_space_data));
	}

	fCount -= count;
}