/*
 * Copyright 2006, Haiku.
 *
 * Copyright (c) 2002-2003 Matthijs Hollemans
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Matthijs Hollemans
 */

#include "debug.h"
#include <MidiEndpoint.h>
#include <MidiRoster.h>
#include "MidiRosterLooper.h"
#include "protocol.h"


const char*
BMidiEndpoint::Name() const
{
	const char* str = NULL;

	// It seems reasonable to assume that the pointer returned by
	// BString::String() can change when the string is modified,
	// e.g. to allocate more space. That's why we lock here too.

	if (LockLooper()) {
		str = fName.String();
		UnlockLooper();
	}

	return str;
}


void
BMidiEndpoint::SetName(const char* newName)
{
	if (newName == NULL) {
		WARN("SetName() does not accept a NULL name");
		return;
	}
	if (IsRemote()) {
		WARN("SetName() is not allowed on remote endpoints");
		return;
	}
	if (!IsValid())
		return;

	if (fName != newName) {
		BMessage msg;
		msg.AddString("midi:name", newName);

		if (SendChangeRequest(&msg) == B_OK) {
			if (LockLooper()) {
				fName.SetTo(newName);
				UnlockLooper();
			}
		}
	}
}


int32
BMidiEndpoint::ID() const
{
	return fId;
}


bool
BMidiEndpoint::IsProducer() const
{
	return !fIsConsumer;
}


bool
BMidiEndpoint::IsConsumer() const
{
	return fIsConsumer;
}


bool
BMidiEndpoint::IsRemote() const
{
	return !fIsLocal;
}


bool
BMidiEndpoint::IsLocal() const
{
	return fIsLocal;
}


bool
BMidiEndpoint::IsPersistent() const
{
	return false;
}


bool
BMidiEndpoint::IsValid() const
{
	if (IsLocal())
		return (ID() > 0);

	// remote endpoint
	return IsRegistered();
}


status_t
BMidiEndpoint::Release()
{
	int32 old = atomic_add(&fRefCount, -1);

	TRACE(("BMidiEndpoint::Release refCount is now %" B_PRId32, old - 1))

	if (old == 1) {
		// If the reference count of a local endpoint drops to zero, 
		// we must delete it. The destructor of BMidiLocalXXX calls
		// BMidiRoster::DeleteLocal(), which does all the hard work.
		// If we are a proxy for a remote endpoint, we must only be
		// deleted if that remote endpoint no longer exists.

		if (IsLocal() || !fIsAlive)
			delete this;
	} else if (old <= 0) {
		debugger("too many calls to Release()");
	}

	return B_OK;
}


status_t
BMidiEndpoint::Acquire()
{
#ifdef DEBUG
	int32 old = 
#endif
	atomic_add(&fRefCount, 1);

	TRACE(("BMidiEndpoint::Acquire refCount is now %" B_PRId32, old + 1))

	return B_OK;
}


status_t
BMidiEndpoint::SetProperties(const BMessage* properties_)
{
	if (properties_ == NULL) {
		WARN("SetProperties() does not accept a NULL message")
		return B_BAD_VALUE;
	} else if (IsRemote()) {
		WARN("SetProperties() is not allowed on remote endpoints");
		return B_ERROR;
	} else if (!IsValid())  {
		return B_ERROR;
	} else {
		BMessage msg;
		msg.AddMessage("midi:properties", properties_);

		status_t err = SendChangeRequest(&msg);
		if (err == B_OK) {
			if (LockLooper()) {
				*fProperties = *properties_;
				UnlockLooper();
			}
		}

		return err;
	}
}


status_t
BMidiEndpoint::GetProperties(BMessage* _properties) const
{
	if (_properties == NULL) {
		WARN("GetProperties() does not accept NULL properties")
		return B_BAD_VALUE;
	}

	if (LockLooper()) {
		*_properties = *fProperties;
		UnlockLooper();
	}

	return B_OK;
}


status_t
BMidiEndpoint::Register()
{
	if (IsRemote()) { 
		WARN("You cannot Register() remote endpoints");
		return B_ERROR; 
	}
	if (IsRegistered()) { 
		WARN("This endpoint is already registered");
		return B_OK; 
	}
	if (!IsValid()) 
		return B_ERROR;

	return SendRegisterRequest(true);
}


status_t
BMidiEndpoint::Unregister()
{
	if (IsRemote()) { 
		WARN("You cannot Unregister() remote endpoints");
		return B_ERROR; 
	}
	if (!IsRegistered()) { 
		WARN("This endpoint is already unregistered");
		return B_OK; 
	}
	if (!IsValid())
		return B_ERROR;

	return SendRegisterRequest(false);
}


BMidiEndpoint::BMidiEndpoint(const char* name_)
{
	TRACE(("BMidiEndpoint::BMidiEndpoint"))

	if (name_ != NULL)
		fName.SetTo(name_);

	fId           = 0;
	fRefCount     = 0;
	fIsLocal      = false;
	fIsRegistered = false;
	fIsAlive      = true;
	
	fProperties	= new BMessage();
}


BMidiEndpoint::~BMidiEndpoint()
{
	TRACE(("BMidiEndpoint::~BMidiEndpoint (%p)", this))

	if (fRefCount > 0) {
		debugger(
			"you should use Release() to dispose of endpoints; "
			"do not \"delete\" them or allocate them on the stack!");
	}
	delete fProperties;
}

//------------------------------------------------------------------------------

void BMidiEndpoint::_Reserved1() { }
void BMidiEndpoint::_Reserved2() { }
void BMidiEndpoint::_Reserved3() { }
void BMidiEndpoint::_Reserved4() { }
void BMidiEndpoint::_Reserved5() { }
void BMidiEndpoint::_Reserved6() { }
void BMidiEndpoint::_Reserved7() { }
void BMidiEndpoint::_Reserved8() { }

//------------------------------------------------------------------------------

status_t
BMidiEndpoint::SendRegisterRequest(bool registered)
{
	BMessage msg;
	msg.AddBool("midi:registered", registered);

	status_t err = SendChangeRequest(&msg);
	if (err == B_OK)  {
		if (LockLooper()) {
			fIsRegistered = registered; 
			UnlockLooper();
		}
	}

	return err;
}


status_t
BMidiEndpoint::SendChangeRequest(BMessage* msg)
{
	ASSERT(msg != NULL)

	msg->what = MSG_CHANGE_ENDPOINT;
	msg->AddInt32("midi:id", ID());

	BMessage reply;
	status_t err = BMidiRoster::MidiRoster()->SendRequest(msg, &reply);
	if (err != B_OK)
		return err;

	status_t res;
	if (reply.FindInt32("midi:result", &res) == B_OK)
		return res;

	return B_ERROR;
}


bool
BMidiEndpoint::IsRegistered() const
{
	// No need to protect this with a lock, because reading
	// and writing a bool is always an atomic operation.

	return fIsRegistered;
}


bool
BMidiEndpoint::LockLooper() const
{
	return BMidiRoster::MidiRoster()->fLooper->Lock();
}


void
BMidiEndpoint::UnlockLooper() const
{
	BMidiRoster::MidiRoster()->fLooper->Unlock();
}