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

#include "MediaClientNode.h"

#include <MediaClient.h>
#include <MediaConnection.h>
#include <MediaRoster.h>
#include <scheduler.h>
#include <TimeSource.h>

#include <string.h>

#include "MediaDebug.h"

#define B_NEW_BUFFER (BTimedEventQueue::B_USER_EVENT + 1)


BMediaClientNode::BMediaClientNode(const char* name,
        BMediaClient* owner, media_type type)
        :
        BMediaNode(name),
        BBufferConsumer(type),
        BBufferProducer(type),
        BMediaEventLooper(),
        fOwner(owner)
{
        CALLED();

        // Configure the node to do the requested jobs
        if (fOwner->Kinds() & B_MEDIA_PLAYER)
                AddNodeKind(B_BUFFER_PRODUCER);
        if (fOwner->Kinds() & B_MEDIA_RECORDER)
                AddNodeKind(B_BUFFER_CONSUMER);
        if (fOwner->Kinds() & B_MEDIA_CONTROLLABLE)
                AddNodeKind(B_CONTROLLABLE);
}


status_t
BMediaClientNode::SendBuffer(BBuffer* buffer, BMediaConnection* conn)
{
        return BBufferProducer::SendBuffer(buffer, conn->_Source(), conn->_Destination());
}


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

        return fOwner->AddOn(id);
}


void
BMediaClientNode::NodeRegistered()
{
        CALLED();

        fOwner->ClientRegistered();

        Run();
}


void
BMediaClientNode::SetRunMode(run_mode mode)
{
        CALLED();

        int32 priority;
        if (mode == BMediaNode::B_OFFLINE)
                priority = B_OFFLINE_PROCESSING;
        else {
                switch(ConsumerType()) {
                        case B_MEDIA_RAW_AUDIO:
                        case B_MEDIA_ENCODED_AUDIO:
                                priority = B_AUDIO_RECORDING;
                                break;

                        case B_MEDIA_RAW_VIDEO:
                        case B_MEDIA_ENCODED_VIDEO:
                                priority = B_VIDEO_RECORDING;
                                break;

                        default:
                                priority = B_DEFAULT_MEDIA_PRIORITY;
                }
        }

        SetPriority(suggest_thread_priority(priority));
        BMediaNode::SetRunMode(mode);
}


void
BMediaClientNode::Start(bigtime_t performanceTime)
{
        CALLED();

        BMediaEventLooper::Start(performanceTime);
}


void
BMediaClientNode::Stop(bigtime_t performanceTime, bool immediate)
{
        CALLED();

        BMediaEventLooper::Stop(performanceTime, immediate);
}


void
BMediaClientNode::Seek(bigtime_t mediaTime, bigtime_t performanceTime)
{
        CALLED();

        BMediaEventLooper::Seek(mediaTime, performanceTime);
}


void
BMediaClientNode::TimeWarp(bigtime_t realTime, bigtime_t performanceTime)
{
        CALLED();

        BMediaEventLooper::TimeWarp(realTime, performanceTime);
}


status_t
BMediaClientNode::HandleMessage(int32 message,
        const void* data, size_t size)
{
        CALLED();

        return B_ERROR;
}


status_t
BMediaClientNode::AcceptFormat(const media_destination& dest,
        media_format* format)
{
        CALLED();

        BMediaInput* conn = fOwner->_FindInput(dest);
        if (conn == NULL)
                return B_MEDIA_BAD_DESTINATION;

        return conn->AcceptFormat(format);
}


status_t
BMediaClientNode::GetNextInput(int32* cookie,
        media_input* input)
{
        CALLED();

        if (fOwner->CountInputs() == 0)
                return B_BAD_INDEX;

        if (*cookie < 0 || *cookie >= fOwner->CountInputs()) {
                *cookie = -1;
                input = NULL;
        } else {
                BMediaInput* conn = fOwner->InputAt(*cookie);
                if (conn != NULL) {
                        *input = conn->fConnection._BuildMediaInput();
                        *cookie += 1;
                        return B_OK;
                }
        }
        return B_BAD_INDEX;
}


void
BMediaClientNode::DisposeInputCookie(int32 cookie)
{
        CALLED();
}


void
BMediaClientNode::BufferReceived(BBuffer* buffer)
{
        CALLED();

        EventQueue()->AddEvent(media_timed_event(buffer->Header()->start_time,
                BTimedEventQueue::B_HANDLE_BUFFER, buffer,
                BTimedEventQueue::B_RECYCLE_BUFFER));
}


status_t
BMediaClientNode::GetLatencyFor(const media_destination& dest,
        bigtime_t* latency, media_node_id* timesource)
{
        CALLED();

        BMediaInput* conn = fOwner->_FindInput(dest);
        if (conn == NULL)
                return B_MEDIA_BAD_DESTINATION;

        //*latency = conn->fLatency;
        *timesource = TimeSource()->ID();
        return B_OK;
}


status_t
BMediaClientNode::Connected(const media_source& source,
        const media_destination& dest, const media_format& format,
        media_input* outInput)
{
        CALLED();

        BMediaInput* conn = fOwner->_FindInput(dest);
        if (conn == NULL)
                return B_MEDIA_BAD_DESTINATION;

        conn->fConnection.source = source;
        conn->fConnection.format = format;

        // Retrieve the node without using GetNodeFor that's pretty inefficient.
        // Unfortunately we don't have an alternative which doesn't require us
        // to release the cloned node.
        // However, our node will not have flags set. Keep in mind this.
        conn->fConnection.remote_node.node
                = BMediaRoster::CurrentRoster()->NodeIDFor(source.port);
        conn->fConnection.remote_node.port = source.port;

        conn->Connected(format);

        *outInput = conn->fConnection._BuildMediaInput();
        return B_OK;
}


void
BMediaClientNode::Disconnected(const media_source& source,
        const media_destination& dest)
{
        CALLED();

        BMediaInput* conn = fOwner->_FindInput(dest);
        if (conn == NULL)
                return;

        if (conn->_Source() == source) {
                // Cleanup the connection
                conn->fConnection.source = media_source::null;
                conn->fConnection.format = media_format();

                conn->fConnection.remote_node.node = -1;
                conn->fConnection.remote_node.port = -1;

                conn->Disconnected();
        }
}


status_t
BMediaClientNode::FormatChanged(const media_source& source,
        const media_destination& dest,
        int32 tag, const media_format& format)
{
        CALLED();
        return B_ERROR;
}


status_t
BMediaClientNode::FormatSuggestionRequested(media_type type,
        int32 quality, media_format* format)
{
        CALLED();

        if (type != ConsumerType()
                        && type != ProducerType()) {
                return B_MEDIA_BAD_FORMAT;
        }

        status_t ret = fOwner->FormatSuggestion(type, quality, format);
        if (ret != B_OK) {
                // In that case we return just a very generic format.
                media_format outFormat;
                outFormat.type = fOwner->MediaType();
                *format = outFormat;
                return B_OK;
        }

        return ret;
}


status_t
BMediaClientNode::FormatProposal(const media_source& source,
        media_format* format)
{
        CALLED();

        BMediaOutput* conn = fOwner->_FindOutput(source);
        if (conn == NULL)
                return B_MEDIA_BAD_DESTINATION;

        return conn->FormatProposal(format);
}


status_t
BMediaClientNode::FormatChangeRequested(const media_source& source,
        const media_destination& dest, media_format* format,
        int32* _deprecated_)
{
        CALLED();

        return B_ERROR;
}


void
BMediaClientNode::LateNoticeReceived(const media_source& source,
        bigtime_t late, bigtime_t when)
{
        CALLED();

}


status_t
BMediaClientNode::GetNextOutput(int32* cookie, media_output* output)
{
        CALLED();

        if (fOwner->CountOutputs() == 0)
                return B_BAD_INDEX;

        if (*cookie < 0 || *cookie >= fOwner->CountOutputs()) {
                *cookie = -1;
                output = NULL;
        } else {
                BMediaOutput* conn = fOwner->OutputAt(*cookie);
                if (conn != NULL) {
                        *output = conn->fConnection._BuildMediaOutput();
                        *cookie += 1;
                        return B_OK;
                }
        }
        return B_BAD_INDEX;
}


status_t
BMediaClientNode::DisposeOutputCookie(int32 cookie)
{
        CALLED();

        return B_OK;
}


status_t
BMediaClientNode::SetBufferGroup(const media_source& source, BBufferGroup* group)
{
        CALLED();

        BMediaOutput* conn = fOwner->_FindOutput(source);
        if (conn == NULL)
                return B_MEDIA_BAD_SOURCE;

        if (group == conn->fBufferGroup)
                return B_OK;

        delete conn->fBufferGroup;

        if (group != NULL) {
                conn->fBufferGroup = group;
                return B_OK;
        }

        conn->fBufferGroup = new BBufferGroup(conn->BufferSize(), 3);
        if (conn->fBufferGroup == NULL)
                return B_NO_MEMORY;

        return conn->fBufferGroup->InitCheck();
}


status_t
BMediaClientNode::PrepareToConnect(const media_source& source,
        const media_destination& dest, media_format* format,
        media_source* out_source, char *name)
{
        CALLED();

        BMediaOutput* conn = fOwner->_FindOutput(source);
        if (conn == NULL)
                return B_MEDIA_BAD_SOURCE;

        if (conn->_Destination() != media_destination::null)
                return B_MEDIA_ALREADY_CONNECTED;

        if (fOwner->MediaType() != B_MEDIA_UNKNOWN_TYPE
                        && format->type != fOwner->MediaType()) {
                return B_MEDIA_BAD_FORMAT;
        }

        conn->fConnection.destination = dest;

        status_t err = conn->PrepareToConnect(format);
        if (err != B_OK)
                return err;

        *out_source = conn->_Source();
        strcpy(name, conn->Name());

        return B_OK;
}


void
BMediaClientNode::Connect(status_t status, const media_source& source,
        const media_destination& dest, const media_format& format,
        char* name)
{
        CALLED();

        BMediaOutput* conn = fOwner->_FindOutput(source);
        if (conn == NULL)
                return;

        // Connection failed, return.
        if (status != B_OK)
                return;

        conn->fConnection.destination = dest;
        conn->fConnection.format = format;

        // Retrieve the node without using GetNodeFor that's pretty inefficient.
        // Unfortunately we don't have an alternative which doesn't require us
        // to release the cloned node.
        // However, our node will not have flags set. Keep in mind this.
        conn->fConnection.remote_node.node
                = BMediaRoster::CurrentRoster()->NodeIDFor(dest.port);
        conn->fConnection.remote_node.port = dest.port;

        strcpy(name, conn->Name());

        // TODO: add correct latency estimate
        SetEventLatency(1000);

        conn->fBufferGroup = new BBufferGroup(conn->BufferSize(), 3);
        if (conn->fBufferGroup == NULL)
                TRACE("Can't allocate the buffer group\n");

        conn->Connected(format);
}


void
BMediaClientNode::Disconnect(const media_source& source,
        const media_destination& dest)
{
        CALLED();

        BMediaOutput* conn = fOwner->_FindOutput(source);
        if (conn == NULL)
                return;

        if (conn->_Destination() == dest) {
                // Cleanup the connection
                delete conn->fBufferGroup;
                conn->fBufferGroup = NULL;

                conn->fConnection.destination = media_destination::null;
                conn->fConnection.format = media_format();

                conn->fConnection.remote_node.node = -1;
                conn->fConnection.remote_node.port = -1;

                conn->Disconnected();
        }
}


void
BMediaClientNode::EnableOutput(const media_source& source,
        bool enabled, int32* _deprecated_)
{
        CALLED();

        BMediaOutput* conn = fOwner->_FindOutput(source);
        if (conn != NULL)
                conn->_SetEnabled(enabled);
}


status_t
BMediaClientNode::GetLatency(bigtime_t* outLatency)
{
        CALLED();

        return BBufferProducer::GetLatency(outLatency);
}


void
BMediaClientNode::LatencyChanged(const media_source& source,
        const media_destination& dest, bigtime_t latency, uint32 flags)
{
        CALLED();
}


void
BMediaClientNode::ProducerDataStatus(const media_destination& dest,
        int32 status, bigtime_t when)
{
        CALLED();
}


void
BMediaClientNode::HandleEvent(const media_timed_event* event,
        bigtime_t late, bool realTimeEvent)
{
        CALLED();

        switch (event->type) {
                // This event is used for inputs which consumes buffers
                // or binded connections which also send them to an output.
                case BTimedEventQueue::B_HANDLE_BUFFER:
                        _HandleBuffer((BBuffer*)event->pointer);
                        break;

                // This is used for connections which produce buffers only.
                case B_NEW_BUFFER:
                        _ProduceNewBuffer(event, late);
                        break;

                case BTimedEventQueue::B_START:
                {
                        if (RunState() != B_STARTED)
                                fOwner->HandleStart(event->event_time);

                        fStartTime = event->event_time;

                        _ScheduleConnections(event->event_time);
                        break;
                }

                case BTimedEventQueue::B_STOP:
                {
                        fOwner->HandleStop(event->event_time);

                        EventQueue()->FlushEvents(0, BTimedEventQueue::B_ALWAYS, true,
                                BTimedEventQueue::B_HANDLE_BUFFER);
                        break;
                }

                case BTimedEventQueue::B_SEEK:
                        fOwner->HandleSeek(event->event_time, event->bigdata);
                        break;

                case BTimedEventQueue::B_WARP:
                        // NOTE: We have no need to handle it
                        break;
        }
}


BMediaClientNode::~BMediaClientNode()
{
        CALLED();

        Quit();
}


void
BMediaClientNode::_ScheduleConnections(bigtime_t eventTime)
{
        for (int32 i = 0; i < fOwner->CountOutputs(); i++) {
                BMediaOutput* output = fOwner->OutputAt(i);

                if (output->HasBinding())
                        continue;

                media_timed_event firstBufferEvent(eventTime,
                        B_NEW_BUFFER);

                output->fFramesSent = 0;

                firstBufferEvent.pointer = (void*) output;
                EventQueue()->AddEvent(firstBufferEvent);
        }
}


void
BMediaClientNode::_HandleBuffer(BBuffer* buffer)
{
        CALLED();

        media_destination dest;
        dest.id = buffer->Header()->destination;
        BMediaInput* conn = fOwner->_FindInput(dest);

        if (conn != NULL)
                conn->HandleBuffer(buffer);

        // TODO: Investigate system level latency logging

        if (conn->HasBinding()) {
                BMediaOutput* output = dynamic_cast<BMediaOutput*>(conn->Binding());
                output->SendBuffer(buffer);
        }
}


void
BMediaClientNode::_ProduceNewBuffer(const media_timed_event* event,
        bigtime_t late)
{
        CALLED();

        if (RunState() != BMediaEventLooper::B_STARTED)
                return;

        // The connection is get through the event
        BMediaOutput* output
                = dynamic_cast<BMediaOutput*>((BMediaConnection*)event->pointer);
        if (output == NULL)
                return;

        if (output->_IsEnabled()) {
                BBuffer* buffer = _GetNextBuffer(output, event->event_time);

                if (buffer != NULL) {
                        if (output->SendBuffer(buffer) != B_OK) {
                                TRACE("BMediaClientNode: Failed to send buffer\n");
                                // The output failed, let's recycle the buffer
                                buffer->Recycle();
                        }
                }
        }

        bigtime_t time = 0;
        media_format format = output->fConnection.format;
        if (format.IsAudio()) {
                size_t nFrames = format.u.raw_audio.buffer_size
                        / ((format.u.raw_audio.format
                                & media_raw_audio_format::B_AUDIO_SIZE_MASK)
                        * format.u.raw_audio.channel_count);
                output->fFramesSent += nFrames;

                time = fStartTime + bigtime_t((1000000LL * output->fFramesSent)
                        / (int32)format.u.raw_audio.frame_rate);
        }

        media_timed_event nextEvent(time, B_NEW_BUFFER);
        EventQueue()->AddEvent(nextEvent);
}


BBuffer*
BMediaClientNode::_GetNextBuffer(BMediaOutput* output, bigtime_t eventTime)
{
        CALLED();

        BBuffer* buffer
                = output->fBufferGroup->RequestBuffer(output->BufferSize(), 0);
        if (buffer == NULL) {
                TRACE("MediaClientNode:::_GetNextBuffer: Failed to get the buffer\n");
                return NULL;
        }

        media_header* header = buffer->Header();
        header->type = output->fConnection.format.type;
        header->size_used = output->BufferSize();
        header->time_source = TimeSource()->ID();
        header->start_time = eventTime;

        return buffer;
}