/*
 * Copyright 2015, Dario Casalinuovo. All rights reserved.
 * Distributed under the terms of the MIT License.
 */

#include <MediaConnection.h>

#include <string.h>

#include "MediaClientNode.h"

#include "MediaDebug.h"


BMediaConnection::BMediaConnection(media_connection_kinds kinds,
	const char* name)
	:
	fOwner(NULL),
	fBind(NULL)
{
	CALLED();

	fConnection.kinds = kinds;
	fConnection.id = -1;
	//fConnection.client = media_client::null;
	if (name != NULL)
		strcpy(fConnection.name, name);
}


BMediaConnection::~BMediaConnection()
{
	CALLED();

}


const media_connection&
BMediaConnection::Connection() const
{
	return fConnection;
}


BMediaClient*
BMediaConnection::Client() const
{
	return fOwner;
}


const char*
BMediaConnection::Name() const
{
	return fConnection.name;
}


bool
BMediaConnection::HasBinding() const
{
	CALLED();

	return fBind != NULL;
}


BMediaConnection*
BMediaConnection::Binding() const
{
	CALLED();

	return fBind;
}


bool
BMediaConnection::IsConnected() const
{
	CALLED();

	return fConnected;
}


status_t
BMediaConnection::Disconnect()
{
	CALLED();

	return fOwner->_DisconnectConnection(this);
}


status_t
BMediaConnection::Release()
{
	CALLED();

	status_t ret = fOwner->_ReleaseConnection(this);
	if (ret != B_OK)
		return ret;

	delete this;
	return ret;
}


void
BMediaConnection::Connected(const media_format& format)
{
	// Update the status of our connection format.
	fConnection.format = format;

	fConnected = true;
}


void
BMediaConnection::Disconnected()
{
	CALLED();

	fConnected = false;
}


void
BMediaConnection::_ConnectionRegistered(BMediaClient* owner,
	media_connection_id id)
{
	fOwner = owner;
	fConnection.id = id;
	fConnection.client = fOwner->Client();

	if (fConnection.IsOutput()) {
		fConnection.source.port = fOwner->fNode->ControlPort();
		fConnection.source.id = fConnection.id;

		fConnection.destination = media_destination::null;
	} else {
		fConnection.destination.port = fOwner->fNode->ControlPort();
		fConnection.destination.id = fConnection.id;

		fConnection.source = media_source::null;
	}
}


const media_source&
BMediaConnection::_Source() const
{
	return fConnection.source;
}


const media_destination&
BMediaConnection::_Destination() const
{
	return fConnection.destination;
}


void BMediaConnection::_ReservedMediaConnection0() {}
void BMediaConnection::_ReservedMediaConnection1() {}
void BMediaConnection::_ReservedMediaConnection2() {}
void BMediaConnection::_ReservedMediaConnection3() {}
void BMediaConnection::_ReservedMediaConnection4() {}
void BMediaConnection::_ReservedMediaConnection5() {}
void BMediaConnection::_ReservedMediaConnection6() {}
void BMediaConnection::_ReservedMediaConnection7() {}
void BMediaConnection::_ReservedMediaConnection8() {}
void BMediaConnection::_ReservedMediaConnection9() {}
void BMediaConnection::_ReservedMediaConnection10() {}


BMediaInput::BMediaInput(const char* name)
	:
	BMediaConnection(B_MEDIA_INPUT, name)
{
}


BMediaInput::~BMediaInput()
{
	CALLED();
}


void
BMediaInput::HandleBuffer(BBuffer* buffer)
{
	CALLED();
}


void
BMediaInput::Connected(const media_format& format)
{
	BMediaConnection::Connected(format);
}


void
BMediaInput::Disconnected()
{
	BMediaConnection::Disconnected();
}


void BMediaInput::_ReservedMediaInput0() {}
void BMediaInput::_ReservedMediaInput1() {}
void BMediaInput::_ReservedMediaInput2() {}
void BMediaInput::_ReservedMediaInput3() {}
void BMediaInput::_ReservedMediaInput4() {}
void BMediaInput::_ReservedMediaInput5() {}
void BMediaInput::_ReservedMediaInput6() {}
void BMediaInput::_ReservedMediaInput7() {}
void BMediaInput::_ReservedMediaInput8() {}
void BMediaInput::_ReservedMediaInput9() {}
void BMediaInput::_ReservedMediaInput10() {}


BMediaOutput::BMediaOutput(const char* name)
	:
	BMediaConnection(B_MEDIA_OUTPUT, name),
	fBufferGroup(NULL)
{
}


BMediaOutput::~BMediaOutput()
{
	CALLED();
}


status_t
BMediaOutput::SendBuffer(BBuffer* buffer)
{
	CALLED();

	if (!IsConnected())
		return B_ERROR;

	return fOwner->fNode->SendBuffer(buffer, this);
}


void
BMediaOutput::Connected(const media_format& format)
{
	BMediaConnection::Connected(format);
}


void
BMediaOutput::Disconnected()
{
	BMediaConnection::Disconnected();
}


bool
BMediaOutput::_IsEnabled() const
{
	CALLED();

	return fEnabled;
}


void
BMediaOutput::_SetEnabled(bool enabled)
{
	fEnabled = enabled;
}


void BMediaOutput::_ReservedMediaOutput0() {}
void BMediaOutput::_ReservedMediaOutput1() {}
void BMediaOutput::_ReservedMediaOutput2() {}
void BMediaOutput::_ReservedMediaOutput3() {}
void BMediaOutput::_ReservedMediaOutput4() {}
void BMediaOutput::_ReservedMediaOutput5() {}
void BMediaOutput::_ReservedMediaOutput6() {}
void BMediaOutput::_ReservedMediaOutput7() {}
void BMediaOutput::_ReservedMediaOutput8() {}
void BMediaOutput::_ReservedMediaOutput9() {}
void BMediaOutput::_ReservedMediaOutput10() {}