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

#include "MediaClient.h"

#include <MediaConnection.h>

#include <MediaRoster.h>
#include <TimeSource.h>

#include "MediaClientNode.h"

#include "MediaDebug.h"


namespace BPrivate { namespace media {


class ConnReleaser {
public:
        ConnReleaser(BMediaConnection* conn)
                :
                fConn(conn) {}

        virtual ~ConnReleaser()
        {
                fConn->Release();
        }

        bool operator== (const ConnReleaser &c1)
        {
                return c1.fConn == this->fConn;
        }

protected:
        BMediaConnection* Obj() const
        {
                return fConn;
        }

private:
        BMediaConnection* fConn;
};


class InputReleaser : public ConnReleaser {
public:
        InputReleaser(BMediaInput* input)
                :
                ConnReleaser(input) {}

        BMediaInput* Obj() const
        {
                return dynamic_cast<BMediaInput*>(ConnReleaser::Obj());
        }
};


class OutputReleaser : public ConnReleaser {
public:
        OutputReleaser(BMediaOutput* output)
                :
                ConnReleaser(output) {}

        BMediaOutput* Obj() const
        {
                return dynamic_cast<BMediaOutput*>(ConnReleaser::Obj());
        }
};


}
}


BMediaClient::BMediaClient(const char* name,
        media_type type, media_client_kinds kinds)
        :
        fLastID(-1)
{
        CALLED();

        fNode = new BMediaClientNode(name, this, type);
        _Init();

        fClient.node = fNode->Node();
        fClient.kinds = kinds;
}


BMediaClient::~BMediaClient()
{
        CALLED();

        _Deinit();
}


const media_client&
BMediaClient::Client() const
{
        return fClient;
}


status_t
BMediaClient::InitCheck() const
{
        CALLED();

        return fInitErr;
}


media_client_kinds
BMediaClient::Kinds() const
{
        CALLED();

        return fClient.Kinds();
}


media_type
BMediaClient::MediaType() const
{
        CALLED();

        // Right now ConsumerType() and ProducerType() are the same.
        return fNode->ConsumerType();
}


status_t
BMediaClient::RegisterInput(BMediaInput* input)
{
        input->_ConnectionRegistered(this, ++fLastID);
        _AddInput(input);
        return B_OK;
}


status_t
BMediaClient::RegisterOutput(BMediaOutput* output)
{
        output->_ConnectionRegistered(this, ++fLastID);
        _AddOutput(output);
        return B_OK;
}


status_t
BMediaClient::Bind(BMediaInput* input, BMediaOutput* output)
{
        CALLED();

        if (input == NULL
                || output == NULL)
                return B_ERROR;

        if (input->fOwner != this || output->fOwner != this)
                return B_ERROR;

        // TODO: Implement binding one input to more outputs.
        if (input->fBind != NULL
                || output->fBind != NULL)
                return B_ERROR;

        input->fBind = output;
        output->fBind = input;
        return B_OK;
}


status_t
BMediaClient::Unbind(BMediaInput* input, BMediaOutput* output)
{
        CALLED();

        if (input == NULL || output == NULL)
                return B_ERROR;

        if (input->fOwner != this || output->fOwner != this)
                return B_ERROR;

        input->fBind = NULL;
        output->fBind = NULL;
        return B_OK;
}


status_t
BMediaClient::Connect(BMediaConnection* ourConnection,
        BMediaConnection* theirConnection)
{
        CALLED();

        return Connect(ourConnection, theirConnection->Connection());
}


status_t
BMediaClient::Connect(BMediaConnection* ourConnection,
        const media_connection& theirConnection)
{
        CALLED();

        BMediaOutput* output = dynamic_cast<BMediaOutput*>(ourConnection);
        if (output != NULL && theirConnection.IsInput())
                return _ConnectInput(output, theirConnection);

        BMediaInput* input = dynamic_cast<BMediaInput*>(ourConnection);
        if (input != NULL && theirConnection.IsOutput())
                return _ConnectOutput(input, theirConnection);

        return B_ERROR;
}


status_t
BMediaClient::Connect(BMediaConnection* connection,
        const media_client& client)
{
        UNIMPLEMENTED();

        return B_ERROR;
}


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

        for (int32 i = 0; i < CountInputs(); i++)
                InputAt(i)->Disconnect();

        for (int32 i = 0; i < CountOutputs(); i++)
                OutputAt(i)->Disconnect();

        return B_OK;
}


int32
BMediaClient::CountInputs() const
{
        CALLED();

        return fInputs.CountItems();
}


int32
BMediaClient::CountOutputs() const
{
        CALLED();

        return fOutputs.CountItems();
}


BMediaInput*
BMediaClient::InputAt(int32 index) const
{
        CALLED();

        return fInputs.ItemAt(index)->Obj();
}


BMediaOutput*
BMediaClient::OutputAt(int32 index) const
{
        CALLED();

        return fOutputs.ItemAt(index)->Obj();
}


BMediaInput*
BMediaClient::FindInput(const media_connection& input) const
{
        CALLED();

        if (!input.IsInput())
                return NULL;

        return _FindInput(input.destination);
}


BMediaOutput*
BMediaClient::FindOutput(const media_connection& output) const
{
        CALLED();

        if (!output.IsOutput())
                return NULL;

        return _FindOutput(output.source);
}


bool
BMediaClient::IsStarted() const
{
        CALLED();

        return fRunning;
}


void
BMediaClient::ClientRegistered()
{
        CALLED();
}


status_t
BMediaClient::Start()
{
        CALLED();

        status_t err = B_OK;
        for (int32 i = 0; i < CountOutputs(); i++) {
                media_node remoteNode = OutputAt(i)->Connection().remote_node;
                if (remoteNode.kind & B_TIME_SOURCE)
                        err = BMediaRoster::CurrentRoster()->StartTimeSource(
                                remoteNode, BTimeSource::RealTime());
                else
                        err = BMediaRoster::CurrentRoster()->StartNode(
                                remoteNode, fNode->TimeSource()->Now());
        }

        return BMediaRoster::CurrentRoster()->StartNode(
                fNode->Node(), fNode->TimeSource()->Now());
}


status_t
BMediaClient::Stop()
{
        CALLED();

        return BMediaRoster::CurrentRoster()->StopNode(
                fNode->Node(), fNode->TimeSource()->Now());
}


status_t
BMediaClient::Seek(bigtime_t mediaTime,
        bigtime_t performanceTime)
{
        CALLED();

        return BMediaRoster::CurrentRoster()->SeekNode(fNode->Node(),
                mediaTime, performanceTime);
}


status_t
BMediaClient::Roll(bigtime_t start, bigtime_t stop, bigtime_t seek)
{
        CALLED();

        return BMediaRoster::CurrentRoster()->RollNode(fNode->Node(),
                start, stop, seek);
}


bigtime_t
BMediaClient::CurrentTime() const
{
        CALLED();

        return fCurrentTime;
}


BMediaAddOn*
BMediaClient::AddOn(int32* id) const
{
        CALLED();

        return NULL;
}


void
BMediaClient::HandleStart(bigtime_t performanceTime)
{
        fRunning = true;
}


void
BMediaClient::HandleStop(bigtime_t performanceTime)
{
        fRunning = false;
}


void
BMediaClient::HandleSeek(bigtime_t mediaTime, bigtime_t performanceTime)
{
}


status_t
BMediaClient::FormatSuggestion(media_type type, int32 quality,
        media_format* format)
{
        return B_ERROR;
}


void
BMediaClient::_Init()
{
        CALLED();

        BMediaRoster* roster = BMediaRoster::Roster(&fInitErr);
        if (fInitErr == B_OK && roster != NULL)
                fInitErr = roster->RegisterNode(fNode);
}


void
BMediaClient::_Deinit()
{
        CALLED();

        if (IsStarted())
                Stop();

        Disconnect();

        // This will release the connections too.
        fInputs.MakeEmpty(true);
        fOutputs.MakeEmpty(true);

        fNode->Release();
}


void
BMediaClient::_AddInput(BMediaInput* input)
{
        CALLED();

        fInputs.AddItem(new InputReleaser(input));
}


void
BMediaClient::_AddOutput(BMediaOutput* output)
{
        CALLED();

        fOutputs.AddItem(new OutputReleaser(output));
}


BMediaInput*
BMediaClient::_FindInput(const media_destination& dest) const
{
        CALLED();

        for (int32 i = 0; i < CountInputs(); i++) {
                if (dest.id == InputAt(i)->_Destination().id)
                        return InputAt(i);
        }
        return NULL;
}


BMediaOutput*
BMediaClient::_FindOutput(const media_source& source) const
{
        CALLED();

        for (int32 i = 0; i < CountOutputs(); i++) {
                if (source.id == OutputAt(i)->_Source().id)
                        return OutputAt(i);
        }
        return NULL;
}


status_t
BMediaClient::_ConnectInput(BMediaOutput* output,
        const media_connection& input)
{
        CALLED();

        if (input.destination == media_destination::null)
                return B_MEDIA_BAD_DESTINATION;

        media_output ourOutput = output->Connection()._BuildMediaOutput();
        media_input theirInput = input._BuildMediaInput();
        media_format format;

        // NOTE: We want to set this data in the callbacks if possible.
        // The correct format should have been set in BMediaConnection::Connected.
        // TODO: Perhaps add some check assert?

        status_t ret = BMediaRoster::CurrentRoster()->Connect(ourOutput.source,
                theirInput.destination, &format, &ourOutput, &theirInput,
                BMediaRoster::B_CONNECT_MUTED);

#if 0
        if (ret == B_OK)
                output->fConnection.format = format;
#endif

        return ret;
}


status_t
BMediaClient::_ConnectOutput(BMediaInput* input,
        const media_connection& output)
{
        CALLED();

        if (output.source == media_source::null)
                return B_MEDIA_BAD_SOURCE;

        media_input ourInput = input->Connection()._BuildMediaInput();
        media_output theirOutput = output._BuildMediaOutput();
        media_format format;

        // NOTE: We want to set this data in the callbacks if possible.
        // The correct format should have been set in BMediaConnection::Connected.
        // TODO: Perhaps add some check assert?

        status_t ret = BMediaRoster::CurrentRoster()->Connect(theirOutput.source,
                ourInput.destination, &format, &theirOutput, &ourInput,
                BMediaRoster::B_CONNECT_MUTED);

#if 0
        if (ret == B_OK)
                input->fConnection.format = format;
#endif

        return ret;
}


status_t
BMediaClient::_DisconnectConnection(BMediaConnection* conn)
{
        CALLED();

        if (conn->Client() != this)
                return B_ERROR;

        const media_connection& handle = conn->Connection();
        if (handle.IsInput()) {
                return BMediaRoster::CurrentRoster()->Disconnect(
                        handle.remote_node.node, handle.source,
                        handle._Node().node, handle.destination);
        } else {
                return BMediaRoster::CurrentRoster()->Disconnect(
                        handle._Node().node, handle.source,
                        handle.remote_node.node, handle.destination);
        }

        return B_ERROR;
}


status_t
BMediaClient::_ReleaseConnection(BMediaConnection* conn)
{
        if (conn->Client() != this)
                return B_ERROR;

        if (conn->Connection().IsInput()) {
                InputReleaser obj(dynamic_cast<BMediaInput*>(conn));
                fInputs.RemoveItem(&obj, false);
                return B_OK;
        } else {
                OutputReleaser obj(dynamic_cast<BMediaOutput*>(conn));
                fOutputs.RemoveItem(&obj, false);
                return B_OK;
        }

        return B_ERROR;
}


void BMediaClient::_ReservedMediaClient0() {}
void BMediaClient::_ReservedMediaClient1() {}
void BMediaClient::_ReservedMediaClient2() {}
void BMediaClient::_ReservedMediaClient3() {}
void BMediaClient::_ReservedMediaClient4() {}
void BMediaClient::_ReservedMediaClient5() {}
void BMediaClient::_ReservedMediaClient6() {}
void BMediaClient::_ReservedMediaClient7() {}
void BMediaClient::_ReservedMediaClient8() {}
void BMediaClient::_ReservedMediaClient9() {}
void BMediaClient::_ReservedMediaClient10() {}