/**********
This library is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the
Free Software Foundation; either version 2.1 of the License, or (at your
option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
This library is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
more details.
You should have received a copy of the GNU Lesser General Public License
along with this library; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
**********/
// Copyright (c) 1996-2016, Live Networks, Inc.  All rights reserved
// Copyright (c) 2016, Dario Casalinuovo. All rights reserved.


#include "rtsp.h"

#include <AdapterIO.h>

#include "RTSPMediaIO.h"


#define REQUEST_STREAMING_OVER_TCP False
#define RECEIVE_BUFFER_SIZE 100000


UsageEnvironment& operator<<(UsageEnvironment& env,
        const RTSPClient& rtspClient)
{
        return env << "[URL:\"" << rtspClient.url() << "\"]: ";
}


UsageEnvironment& operator<<(UsageEnvironment& env,
        const MediaSubsession& subsession)
{
        return env << subsession.mediumName() << "/" << subsession.codecName();
}


class AdapterSink : public MediaSink
{
public:
                        static                          AdapterSink* createNew(UsageEnvironment& env,
                                                                        MediaSubsession& subsession,
                                                                        BInputAdapter* inputAdapter,
                                                                        char const* streamId = NULL);

private:
                                                                AdapterSink(UsageEnvironment& env,
                                                                        MediaSubsession& subsession,
                                                                        char const* streamId,
                                                                        BInputAdapter* inputAdapter);

        virtual                                         ~AdapterSink();

                        static void                     afterGettingFrame(void* clientData,
                                                                        unsigned frameSize,
                                                                        unsigned numTruncatedBytes,
                                                                        struct timeval presentationTime,
                                                                        unsigned durationInMicroseconds);

                        void                            afterGettingFrame(unsigned frameSize,
                                                                        unsigned numTruncatedBytes,
                                                                        struct timeval presentationTime,
                                                                        unsigned durationInMicroseconds);

private:
        // redefined virtual functions:
        virtual Boolean                         continuePlaying();

private:
                        BInputAdapter*          fInputAdapter;
                        u_int8_t*                       fReceiveBuffer;
                        MediaSubsession&        fSubsession;
                        char*                           fStreamId;
};

// Implementation of the RTSP 'response handlers':

void continueAfterDESCRIBE(RTSPClient* rtspClient,
        int resultCode, char* resultString)
{
        UsageEnvironment& env = rtspClient->envir();
        HaikuRTSPClient* client = (HaikuRTSPClient*) rtspClient;
        do {
                if (resultCode != 0) {
                        env << *rtspClient << "Failed to get a SDP description: "
                                << resultString << "\n";
                        delete[] resultString;

                        break;
                }

                char* const sdpDescription = resultString;
                env << *rtspClient << "Got a SDP description:\n"
                        << sdpDescription << "\n";

                // Create a media session object from this SDP description:
                client->session = MediaSession::createNew(env, sdpDescription);
                delete[] sdpDescription; // because we don't need it anymore
                if (client->session == NULL) {
                        env << *rtspClient
                                << "Failed to create a MediaSession object "
                                        "from the SDP description: "
                                << env.getResultMsg() << "\n";

                        break;
                } else if (!client->session->hasSubsessions()) {
                        env << *rtspClient << "This session has no media subsessions"
                                " (i.e., no \"m=\" lines)\n";

                        break;
                }

                // Then, create and set up our data source objects for the session.
                // We do this by iterating over the session's 'subsessions',
                // calling "MediaSubsession::initiate()",
                // and then sending a RTSP "SETUP" command, on each one.
                // (Each 'subsession' will have its own data source.)
                client->iter = new MediaSubsessionIterator(*client->session);
                setupNextSubsession(rtspClient);
                return;
        } while (0);

        // An unrecoverable error occurred with this stream.
        shutdownStream(rtspClient);
}


void setupNextSubsession(RTSPClient* rtspClient)
{
        UsageEnvironment& env = rtspClient->envir();
        HaikuRTSPClient* client = (HaikuRTSPClient*) rtspClient;

        client->subsession = client->iter->next();
        if (client->subsession != NULL) {
                if (!client->subsession->initiate()) {

                        env << *rtspClient << "Failed to initiate the \""
                                << *client->subsession << "\" subsession: "
                                << env.getResultMsg() << "\n";

                        // give up on this subsession; go to the next one
                        setupNextSubsession(rtspClient);
                }
                else {
                        env << *rtspClient << "Initiated the \""
                                << *client->subsession << "\" subsession (";

                        if (client->subsession->rtcpIsMuxed()) {
                                env << "client port " << client->subsession->clientPortNum();
                        } else {
                                env << "client ports " << client->subsession->clientPortNum()
                                        << "-" << client->subsession->clientPortNum() + 1;
                        }
                        env << ")\n";

                        // Continue setting up this subsession,
                        // by sending a RTSP "SETUP" command:
                        rtspClient->sendSetupCommand(*client->subsession,
                                continueAfterSETUP, False, REQUEST_STREAMING_OVER_TCP);
                }
                return;
        }

        // We've finished setting up all of the subsessions.
        // Now, send a RTSP "PLAY" command to start the streaming:
        if (client->session->absStartTime() != NULL) {
                // Special case: The stream is indexed by 'absolute' time,
                // so send an appropriate "PLAY" command:
                rtspClient->sendPlayCommand(*client->session, continueAfterPLAY,
                        client->session->absStartTime(), client->session->absEndTime());
        } else {
                client->duration = client->session->playEndTime()
                        - client->session->playStartTime();
                rtspClient->sendPlayCommand(*client->session, continueAfterPLAY);
        }
}


void continueAfterSETUP(RTSPClient* rtspClient,
        int resultCode, char* resultString)
{
        do {
                UsageEnvironment& env = rtspClient->envir();
                HaikuRTSPClient* client = (HaikuRTSPClient*) rtspClient;

                if (resultCode != 0) {
                        env << *rtspClient << "Failed to set up the \""
                                << *client->subsession << "\" subsession: "
                                << resultString << "\n";
                        break;
                }

                env << *rtspClient << "Set up the \""
                        << *client->subsession << "\" subsession (";
                if (client->subsession->rtcpIsMuxed()) {
                        env << "client port " << client->subsession->clientPortNum();
                } else {
                        env << "client ports " << client->subsession->clientPortNum()
                                << "-" << client->subsession->clientPortNum() + 1;
                }
                env << ")\n";

                // Having successfully setup the subsession, create a data sink for it,
                // and call "startPlaying()" on it.
                // (This will prepare the data sink to receive data; the actual
                // flow of data from the client won't start happening until later,
                // after we've sent a RTSP "PLAY" command.)

                client->subsession->sink = AdapterSink::createNew(env, *client->subsession,
                        ((HaikuRTSPClient*)rtspClient)->GetInputAdapter(), rtspClient->url());
                // perhaps use your own custom "MediaSink" subclass instead
                if (client->subsession->sink == NULL) {
                        env << *rtspClient << "Failed to create a data sink for the \""
                                << *client->subsession << "\" subsession: "
                                << env.getResultMsg() << "\n";
                        break;
                }

                env << *rtspClient << "Created a data sink for the \""
                        << *client->subsession << "\" subsession\n";
                // a hack to let subsession handler functions
                // get the "RTSPClient" from the subsession
                client->subsession->miscPtr = rtspClient;
                client->subsession->sink
                                ->startPlaying(*(client->subsession->readSource()),
                                        subsessionAfterPlaying, client->subsession);
                // Also set a handler to be called if a RTCP "BYE"
                // arrives for this subsession:
                if (client->subsession->rtcpInstance() != NULL) {
                        client->subsession->rtcpInstance()->setByeHandler(
                                subsessionByeHandler,
                                client->subsession);
                }
        } while (0);
        delete[] resultString;

        // Set up the next subsession, if any:
        setupNextSubsession(rtspClient);
}


void continueAfterPLAY(RTSPClient* rtspClient,
        int resultCode, char* resultString)
{
        Boolean success = False;
        UsageEnvironment& env = rtspClient->envir();
        HaikuRTSPClient* client = (HaikuRTSPClient*) rtspClient;

        do {
                if (resultCode != 0) {
                        env << *rtspClient << "Failed to start playing session: "
                                << resultString << "\n";
                        break;
                }

                // Set a timer to be handled at the end of the stream's
                // expected duration (if the stream does not already signal its end
                // using a RTCP "BYE").  This is optional.  If, instead, you want
                // to keep the stream active - e.g., so you can later
                // 'seek' back within it and do another RTSP "PLAY"
                // - then you can omit this code.
                // (Alternatively, if you don't want to receive the entire stream,
                // you could set this timer for some shorter value.)
                if (client->duration > 0) {
                        // number of seconds extra to delay,
                        // after the stream's expected duration.  (This is optional.)
                        unsigned const delaySlop = 2;
                        client->duration += delaySlop;
                        unsigned uSecsToDelay = (unsigned)(client->duration * 1000000);
                        client->streamTimerTask
                                = env.taskScheduler().scheduleDelayedTask(uSecsToDelay,
                                        (TaskFunc*)streamTimerHandler, rtspClient);
                }

                env << *rtspClient << "Started playing session";
                if (client->duration > 0) {
                        env << " (for up to " << client->duration << " seconds)";
                }
                env << "...\n";

                success = True;
        } while (0);
        delete[] resultString;

        if (!success) {
                // An unrecoverable error occurred with this stream.
                shutdownStream(rtspClient);
        } else
                client->NotifySucces();
}

// Implementation of the other event handlers:

void subsessionAfterPlaying(void* clientData)
{
        MediaSubsession* subsession = (MediaSubsession*)clientData;
        RTSPClient* rtspClient = (RTSPClient*)(subsession->miscPtr);

        // Begin by closing this subsession's stream:
        Medium::close(subsession->sink);
        subsession->sink = NULL;

        // Next, check whether *all* subsessions' streams have now been closed:
        MediaSession& session = subsession->parentSession();
        MediaSubsessionIterator iter(session);
        while ((subsession = iter.next()) != NULL) {
                if (subsession->sink != NULL)
                        return; // this subsession is still active
        }

        // All subsessions' streams have now been closed, so shutdown the client:
        shutdownStream(rtspClient);
}


void subsessionByeHandler(void* clientData)
{
        MediaSubsession* subsession = (MediaSubsession*)clientData;
        RTSPClient* rtspClient = (RTSPClient*)subsession->miscPtr;
        UsageEnvironment& env = rtspClient->envir();

        env << *rtspClient << "Received RTCP \"BYE\" on \""
                << *subsession << "\" subsession\n";

        // Now act as if the subsession had closed:
        subsessionAfterPlaying(subsession);
}


void streamTimerHandler(void* clientData)
{
        HaikuRTSPClient* client = (HaikuRTSPClient*)clientData;

        client->streamTimerTask = NULL;

        // Shut down the stream:
        shutdownStream(client);
}


void shutdownStream(RTSPClient* rtspClient, int exitCode)
{
        UsageEnvironment& env = rtspClient->envir();
        HaikuRTSPClient* client = (HaikuRTSPClient*) rtspClient;

        // First, check whether any subsessions have still to be closed:
        if (client->session != NULL) {
                Boolean someSubsessionsWereActive = False;
                MediaSubsessionIterator iter(*client->session);
                MediaSubsession* subsession;

                while ((subsession = iter.next()) != NULL) {
                        if (subsession->sink != NULL) {
                                Medium::close(subsession->sink);
                                subsession->sink = NULL;

                                if (subsession->rtcpInstance() != NULL) {
                                        // in case the server sends a RTCP "BYE"
                                        // while handling "TEARDOWN"
                                        subsession->rtcpInstance()->setByeHandler(NULL, NULL);
                                }

                                someSubsessionsWereActive = True;
                        }
                }

                if (someSubsessionsWereActive) {
                        // Send a RTSP "TEARDOWN" command,
                        // to tell the server to shutdown the stream.
                        // Don't bother handling the response to the "TEARDOWN".
                        rtspClient->sendTeardownCommand(*client->session, NULL);
                }
        }

        env << *rtspClient << "Closing the stream.\n";
        Medium::close(rtspClient);
        // Note that this will also cause this stream's
        // "StreamClientState" structure to get reclaimed.
        client->NotifyError();
}


AdapterSink* AdapterSink::createNew(UsageEnvironment& env,
        MediaSubsession& subsession, BInputAdapter* inputAdapter,
        char const* streamId)
{
        return new AdapterSink(env, subsession, streamId, inputAdapter);
}


AdapterSink::AdapterSink(UsageEnvironment& env, MediaSubsession& subsession,
        char const* streamId, BInputAdapter* inputAdapter)
        :
        MediaSink(env),
        fSubsession(subsession),
        fInputAdapter(inputAdapter)
{
        fStreamId = strDup(streamId);
        fReceiveBuffer = new u_int8_t[RECEIVE_BUFFER_SIZE];
}


AdapterSink::~AdapterSink()
{
        delete[] fReceiveBuffer;
        delete[] fStreamId;
}


void AdapterSink::afterGettingFrame(void* clientData, unsigned frameSize,
        unsigned numTruncatedBytes, struct timeval presentationTime,
        unsigned durationInMicroseconds)
{
        AdapterSink* sink = (AdapterSink*)clientData;
        sink->afterGettingFrame(frameSize, numTruncatedBytes,
                presentationTime, durationInMicroseconds);
}


void
AdapterSink::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes,
        struct timeval presentationTime, unsigned /*durationInMicroseconds*/)
{
        fInputAdapter->Write(fReceiveBuffer, frameSize);
        continuePlaying();
}


Boolean
AdapterSink::continuePlaying()
{
        if (fSource == NULL)
                return False;

        fSource->getNextFrame(fReceiveBuffer, RECEIVE_BUFFER_SIZE,
                afterGettingFrame, this,
                onSourceClosure, this);
        return True;
}