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

#include <new>

#include <AutoDeleter.h>

#include "AreaSupport.h"
#include "Compatibility.h"
#include "Port.h"


using std::nothrow;

// minimal and maximal port size
static const int32 kMinPortSize = 1024;			// 1 kB
static const int32 kMaxPortSize = 64 * 1024;	// 64 kB


// constructor
Port::Port(int32 size)
	:
	fBuffer(NULL),
	fCapacity(0),
	fReservedSize(0),
	fInitStatus(B_NO_INIT),
	fOwner(true)
{
	// adjust size to be within the sane bounds
	if (size < kMinPortSize)
		size = kMinPortSize;
	else if (size > kMaxPortSize)
		size = kMaxPortSize;
	// allocate the buffer
	fBuffer = new(nothrow) uint8[size];
	if (!fBuffer) {
		fInitStatus = B_NO_MEMORY;
		return;
	}
	// create the owner port
	fInfo.owner_port = create_port(1, "port owner port");
	if (fInfo.owner_port < 0) {
		fInitStatus = fInfo.owner_port;
		return;
	}
	// create the client port
	fInfo.client_port = create_port(1, "port client port");
	if (fInfo.client_port < 0) {
		fInitStatus = fInfo.client_port;
		return;
	}
	fInfo.size = size;
	fCapacity = size;
	fInitStatus = B_OK;
}


// constructor
Port::Port(const Info* info)
	:
	fBuffer(NULL),
	fCapacity(0),
	fReservedSize(0),
	fInitStatus(B_NO_INIT),
	fOwner(false)
{
	// check parameters
	if (!info || info->owner_port < 0 || info->client_port < 0
		|| info->size < kMinPortSize || info->size > kMaxPortSize) {
		return;
	}
	// allocate the buffer
	fBuffer = new(nothrow) uint8[info->size];
	if (!fBuffer) {
		fInitStatus = B_NO_MEMORY;
		return;
	}
	// init the info
	fInfo.owner_port = info->owner_port;
	fInfo.client_port = info->client_port;
	fInfo.size = info->size;
	// init the other members
	fCapacity = info->size;
	fInitStatus = B_OK;
}


// destructor
Port::~Port()
{
	Close();
	delete[] fBuffer;
}


// Close
void
Port::Close()
{
	if (fInitStatus != B_OK)
		return;
	fInitStatus = B_NO_INIT;
	// delete the ports only if we are the owner
	if (fOwner) {
		if (fInfo.owner_port >= 0)
			delete_port(fInfo.owner_port);
		if (fInfo.client_port >= 0)
			delete_port(fInfo.client_port);
	}
	fInfo.owner_port = -1;
	fInfo.client_port = -1;
}


// InitCheck
status_t
Port::InitCheck() const
{
	return fInitStatus;
}


// GetInfo
const Port::Info*
Port::GetInfo() const
{
	return &fInfo;
}


// Reserve
void
Port::Reserve(int32 endOffset)
{
	if (endOffset > fReservedSize)
		fReservedSize = endOffset;
}


// Unreserve
void
Port::Unreserve(int32 endOffset)
{
	if (endOffset < fReservedSize)
		fReservedSize = endOffset;
}


// Send
status_t
Port::Send(const void* message, int32 size)
{
	if (fInitStatus != B_OK)
		return fInitStatus;
	if (size <= 0)
		return B_BAD_VALUE;

	port_id port = (fOwner ? fInfo.client_port : fInfo.owner_port);
	status_t error;
	do {
		error = write_port(port, 0, message, size);
	} while (error == B_INTERRUPTED);

	return (fInitStatus = error);
}


// Receive
status_t
Port::Receive(void** _message, size_t* _size, bigtime_t timeout)
{
	if (fInitStatus != B_OK)
		return fInitStatus;

	// convert to timeout to flags + timeout we can use in the loop
	uint32 timeoutFlags = 0;
	if (timeout < 0) {
		timeout = 0;
	} else if (timeout == 0) {
		timeoutFlags = B_RELATIVE_TIMEOUT;
	} else if (timeout >= 0) {
		timeout += system_time();
		timeoutFlags = B_ABSOLUTE_TIMEOUT;
	}

	port_id port = (fOwner ? fInfo.owner_port : fInfo.client_port);

	// wait for the next message
	status_t error = B_OK;
	ssize_t bufferSize;
	do {
		// TODO: When compiling for userland, we might want to save this syscall
		// by using read_port_etc() directly, using a sufficiently large
		// on-stack buffer and copying onto the heap.
		bufferSize = port_buffer_size_etc(port, timeoutFlags, timeout);
		if (bufferSize < 0)
			error = bufferSize;
	} while (error == B_INTERRUPTED);

	if (error == B_TIMED_OUT || error == B_WOULD_BLOCK)
		return error;
	if (error != B_OK)
		return (fInitStatus = error);

	// allocate memory for the message
	void* message = malloc(bufferSize);
	if (message == NULL)
		return (fInitStatus = B_NO_MEMORY);
	MemoryDeleter messageDeleter(message);

	// read the message
	int32 code;
	ssize_t bytesRead = read_port_etc(port, &code, message, bufferSize,
		B_RELATIVE_TIMEOUT, 0);
	if (bytesRead < 0)
		return fInitStatus = bytesRead;
	if (bytesRead != bufferSize)
		return fInitStatus = B_BAD_DATA;

	messageDeleter.Detach();
	*_message = message;
	*_size = bytesRead;

	return B_OK;
}