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


#include "RTSPMediaIO.h"


#define LIVE555_VERBOSITY 1


RTSPMediaIO::RTSPMediaIO(BUrl ourUrl)
        :
        BAdapterIO(
                B_MEDIA_STREAMING | B_MEDIA_MUTABLE_SIZE | B_MEDIA_SEEK_BACKWARD,
                B_INFINITE_TIMEOUT),
        fUrl(ourUrl),
        fClient(NULL),
        fScheduler(NULL),
        fLoopWatchVariable(0),
        fLoopThread(-1)
{
        fScheduler = BasicTaskScheduler::createNew();
        fEnv = BasicUsageEnvironment::createNew(*fScheduler);
}


RTSPMediaIO::~RTSPMediaIO()
{
        fClient->Close();

        ShutdownLoop();

        status_t status;
        if (fLoopThread != -1)
                wait_for_thread(fLoopThread, &status);
}


ssize_t
RTSPMediaIO::WriteAt(off_t position, const void* buffer, size_t size)
{
        return B_NOT_SUPPORTED;
}


status_t
RTSPMediaIO::SetSize(off_t size)
{
        return B_NOT_SUPPORTED;
}


status_t
RTSPMediaIO::Open()
{
        fClient = new HaikuRTSPClient(*fEnv, fUrl.UrlString(),
                0, this);
        if (fClient == NULL)
                return B_ERROR;

        fClient->sendDescribeCommand(continueAfterDESCRIBE);

        fLoopThread = spawn_thread(_LoopThread, "two minutes hate thread",
                B_NORMAL_PRIORITY, this);

        if (fLoopThread <= 0 || resume_thread(fLoopThread) != B_OK)
                return B_ERROR;

        return fClient->WaitForInit(5000000);
}


int32
RTSPMediaIO::_LoopThread(void* data)
{
        static_cast<RTSPMediaIO *>(data)->LoopThread();
        return 0;
}


void
RTSPMediaIO::LoopThread()
{
        fEnv->taskScheduler().doEventLoop(&fLoopWatchVariable);
        fLoopThread = -1;
}


void
RTSPMediaIO::ShutdownLoop()
{
        fLoopWatchVariable = 1;
}


HaikuRTSPClient::HaikuRTSPClient(UsageEnvironment& env, char const* rtspURL,
                portNumBits tunnelOverHTTPPortNum, RTSPMediaIO* interface)
        :
        RTSPClient(env, rtspURL, LIVE555_VERBOSITY, "Haiku RTSP Streamer",
                tunnelOverHTTPPortNum, -1),
        iter(NULL),
        session(NULL),
        subsession(NULL),
        streamTimerTask(NULL),
        duration(0.0f),
        fInterface(interface),
        fInitPort(-1)
{
        fInitPort = create_port(1, "RTSP Client wait port");
}


HaikuRTSPClient::~HaikuRTSPClient()
{
}


void
HaikuRTSPClient::Close()
{
        delete iter;
        if (session != NULL) {
                UsageEnvironment& env = session->envir();
                env.taskScheduler().unscheduleDelayedTask(streamTimerTask);
                Medium::close(session);
        }
}


status_t
HaikuRTSPClient::WaitForInit(bigtime_t timeout)
{
        status_t status = B_ERROR;
        if (read_port_etc(fInitPort, NULL, &status,
                        sizeof(status), B_RELATIVE_TIMEOUT, timeout) < 0) {
                return B_ERROR;
        }

        close_port(fInitPort);
        delete_port(fInitPort);
        fInitPort = -1;
        return status;
}


void
HaikuRTSPClient::NotifyError()
{
        fInterface->ShutdownLoop();
        status_t status = B_ERROR;
        write_port(fInitPort, NULL, &status, sizeof(status));
}


void
HaikuRTSPClient::NotifySucces()
{
        status_t status = B_OK;
        write_port(fInitPort, NULL, &status, sizeof(status));
}


BInputAdapter*
HaikuRTSPClient::GetInputAdapter() const
{
        return fInterface->BuildInputAdapter();
}