/*  This file is part of the KDE project.

Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

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 or 3 of the License.

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, see <http://www.gnu.org/licenses/>.

*/

#include <QResource>
#include <QUrl>

#include "abstractmediaplayer.h"
#include "defs.h"
#include "mediaobject.h"
#include "utils.h"
#include <cdbcols.h>
#include <cdblen.h>
#include <commdb.h>

QT_BEGIN_NAMESPACE

using namespace Phonon;
using namespace Phonon::MMF;

/*! \class MMF::AbstractMediaPlayer
  \internal
*/

//-----------------------------------------------------------------------------
// Constants
//-----------------------------------------------------------------------------

const int       NullMaxVolume = -1;
const int       BufferStatusTimerInterval = 100; // ms


//-----------------------------------------------------------------------------
// Constructor / destructor
//-----------------------------------------------------------------------------

MMF::AbstractMediaPlayer::AbstractMediaPlayer
    (MediaObject *parent, const AbstractPlayer *player)
        :   AbstractPlayer(player)
        ,   m_parent(parent)
        ,   m_pending(NothingPending)
        ,   m_positionTimer(new QTimer(this))
        ,   m_position(0)
        ,   m_bufferStatusTimer(new QTimer(this))
        ,   m_mmfMaxVolume(NullMaxVolume)
        ,   m_prefinishMarkSent(false)
        ,   m_aboutToFinishSent(false)
#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
        ,   m_download(0)
        ,   m_downloadStalled(false)
#endif
{
    connect(m_positionTimer.data(), SIGNAL(timeout()), this, SLOT(positionTick()));
    connect(m_bufferStatusTimer.data(), SIGNAL(timeout()), this, SLOT(bufferStatusTick()));
}

//-----------------------------------------------------------------------------
// MediaObjectInterface
//-----------------------------------------------------------------------------

void MMF::AbstractMediaPlayer::play()
{
    TRACE_CONTEXT(AbstractMediaPlayer::play, EAudioApi);
    TRACE_ENTRY("state %d", privateState());

    switch (privateState()) {
    case GroundState:
        setError(tr("Not ready to play"));
        break;

    case LoadingState:
        setPending(PlayPending);
        break;

    case StoppedState:
    case PausedState:
        startPlayback();
        break;

    case PlayingState:
    case BufferingState:
    case ErrorState:
        // Do nothing
        break;

        // Protection against adding new states and forgetting to update this switch
    default:
        TRACE_PANIC(InvalidStatePanic);
    }

    TRACE_EXIT("state %d", privateState());
}

void MMF::AbstractMediaPlayer::pause()
{
    TRACE_CONTEXT(AbstractMediaPlayer::pause, EAudioApi);
    TRACE_ENTRY("state %d", privateState());

    stopTimers();

    switch (privateState()) {
    case GroundState:
    case LoadingState:
    case StoppedState:
        setPending(PausePending);
        break;

    case PausedState:
        // Do nothing
        break;

    case PlayingState:
    case BufferingState:
        changeState(PausedState);
        // Fall through
    case ErrorState:
        doPause();
        break;

        // Protection against adding new states and forgetting to update this switch
    default:
        TRACE_PANIC(InvalidStatePanic);
    }

    TRACE_EXIT("state %d", privateState());
}

void MMF::AbstractMediaPlayer::stop()
{
    TRACE_CONTEXT(AbstractMediaPlayer::stop, EAudioApi);
    TRACE_ENTRY("state %d", privateState());

    setPending(NothingPending);
    stopTimers();

    switch (privateState()) {
    case GroundState:
    case LoadingState:
    case StoppedState:
    case ErrorState:
        // Do nothing
        break;

    case PlayingState:
    case BufferingState:
    case PausedState:
        doStop();
        changeState(StoppedState);
        break;

        // Protection against adding new states and forgetting to update this switch
    default:
        TRACE_PANIC(InvalidStatePanic);
    }

    TRACE_EXIT("state %d", privateState());
}

void MMF::AbstractMediaPlayer::seek(qint64 ms)
{
    TRACE_CONTEXT(AbstractMediaPlayer::seek, EAudioApi);
    TRACE_ENTRY("state %d pos %Ld", state(), ms);

    switch (privateState()) {
    // Fallthrough all these
    case GroundState:
    case StoppedState:
    case PausedState:
    case PlayingState:
    case LoadingState:
    {
        bool wasPlaying = false;
        if (state() == PlayingState) {
            stopPositionTimer();
            doPause();
            wasPlaying = true;
        }

        doSeek(ms);
        m_position = ms;
        resetMarksIfRewound();

        if(wasPlaying && state() != ErrorState) {
            doPlay();
            startPositionTimer();
        }

        break;
    }
    case BufferingState:
    // Fallthrough
    case ErrorState:
        // Do nothing
        break;
    }

    TRACE_EXIT_0();
}

bool MMF::AbstractMediaPlayer::isSeekable() const
{
    return true;
}

qint64 MMF::AbstractMediaPlayer::currentTime() const
{
    return m_position;
}

void MMF::AbstractMediaPlayer::doSetTickInterval(qint32 interval)
{
    TRACE_CONTEXT(AbstractMediaPlayer::doSetTickInterval, EAudioApi);
    TRACE_ENTRY("state %d m_interval %d interval %d", privateState(), tickInterval(), interval);

    m_positionTimer->setInterval(interval);

    TRACE_EXIT_0();
}

void MMF::AbstractMediaPlayer::open()
{
    TRACE_CONTEXT(AbstractMediaPlayer::open, EAudioApi);
    const MediaSource source = m_parent->source();
    TRACE_ENTRY("state %d source.type %d", privateState(), source.type());

    close();
    changeState(GroundState);

    TInt symbianErr = KErrNone;
    QString errorMessage;

    switch (source.type()) {
    case MediaSource::LocalFile: {
        RFile *const file = m_parent->file();
        Q_ASSERT(file);
        symbianErr = openFile(*file);
        if (KErrNone != symbianErr)
            errorMessage = tr("Error opening file");
        break;
    }

    case MediaSource::Url: {
        const QUrl url(source.url());
        if (url.scheme() == QLatin1String("file")) {
            RFile *const file = m_parent->file();
            Q_ASSERT(file);
            symbianErr = openFile(*file);
            if (KErrNone != symbianErr)
                errorMessage = tr("Error opening file");
        }
#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
        else if (url.scheme() == QLatin1String("http")) {
            Q_ASSERT(!m_download);
            m_download = new Download(url, this);
            connect(m_download, SIGNAL(lengthChanged(qint64)),
                    this, SLOT(downloadLengthChanged(qint64)));
            connect(m_download, SIGNAL(stateChanged(Download::State)),
                    this, SLOT(downloadStateChanged(Download::State)));
            int iap = m_parent->currentIAP();
            TRACE("HTTP Url: Using IAP %d", iap);
            m_download->start(iap);
        }
#endif
        else {
            int iap = m_parent->currentIAP();
            TRACE("Using IAP %d", iap);
            symbianErr = openUrl(url.toString(), iap);
            if (KErrNone != symbianErr)
                errorMessage = tr("Error opening URL");
        }

        break;
    }

    case MediaSource::Stream: {
        QResource *const resource = m_parent->resource();
        if (resource) {
            m_buffer.Set(resource->data(), resource->size());
            symbianErr = openDescriptor(m_buffer);
            if (KErrNone != symbianErr)
                errorMessage = tr("Error opening resource");
        } else {
            errorMessage = tr("Error opening source: resource not opened");
        }
        break;
    }

    // Other source types are handled in MediaObject::createPlayer

    // Protection against adding new media types and forgetting to update this switch
    default:
        TRACE_PANIC(InvalidMediaTypePanic);
    }

    if (errorMessage.isEmpty()) {
        changeState(LoadingState);
    } else {
        if (symbianErr)
            setError(errorMessage, symbianErr);
        else
            setError(errorMessage);
    }

    TRACE_EXIT_0();
}

void MMF::AbstractMediaPlayer::close()
{
    doClose();
#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
    delete m_download;
    m_download = 0;
#endif
    m_position = 0;
}

void MMF::AbstractMediaPlayer::volumeChanged(qreal volume)
{
    TRACE_CONTEXT(AbstractMediaPlayer::volumeChanged, EAudioInternal);
    TRACE_ENTRY("state %d", privateState());

    AbstractPlayer::volumeChanged(volume);
    doVolumeChanged();

    TRACE_EXIT_0();
}

//-----------------------------------------------------------------------------
// Private functions
//-----------------------------------------------------------------------------

void MMF::AbstractMediaPlayer::startPositionTimer()
{
    m_positionTimer->start(tickInterval());
}

void MMF::AbstractMediaPlayer::stopPositionTimer()
{
    m_positionTimer->stop();
}

void MMF::AbstractMediaPlayer::startBufferStatusTimer()
{
    m_bufferStatusTimer->start(BufferStatusTimerInterval);
}

void MMF::AbstractMediaPlayer::stopBufferStatusTimer()
{
    m_bufferStatusTimer->stop();
}

void MMF::AbstractMediaPlayer::stopTimers()
{
    stopPositionTimer();
    stopBufferStatusTimer();
}

void MMF::AbstractMediaPlayer::doVolumeChanged()
{
    switch (privateState()) {
    case GroundState:
    case LoadingState:
    case ErrorState:
        // Do nothing
        break;

    case StoppedState:
    case PausedState:
    case PlayingState:
    case BufferingState: {
        const qreal volume = (m_volume * m_mmfMaxVolume) + 0.5;
        const int err = setDeviceVolume(volume);

        if (KErrNone != err) {
            setError(tr("Setting volume failed"), err);
        }
        break;
    }

    // Protection against adding new states and forgetting to update this
    // switch
    default:
        Utils::panic(InvalidStatePanic);
    }
}

//-----------------------------------------------------------------------------
// Protected functions
//-----------------------------------------------------------------------------

void MMF::AbstractMediaPlayer::bufferingStarted()
{
    m_stateBeforeBuffering = privateState();
    changeState(BufferingState);
    bufferStatusTick();
    startBufferStatusTimer();
}

void MMF::AbstractMediaPlayer::bufferingComplete()
{
    stopBufferStatusTimer();
    emit MMF::AbstractPlayer::bufferStatus(100);
    if (!progressiveDownloadStalled())
        changeState(m_stateBeforeBuffering);
}

void MMF::AbstractMediaPlayer::maxVolumeChanged(int mmfMaxVolume)
{
    m_mmfMaxVolume = mmfMaxVolume;
    doVolumeChanged();
}

void MMF::AbstractMediaPlayer::loadingComplete(int error)
{
    TRACE_CONTEXT(AbstractMediaPlayer::loadingComplete, EAudioApi);
    TRACE_ENTRY("state %d error %d", state(), error);
    if (progressiveDownloadStalled()) {
        Q_ASSERT(Phonon::BufferingState == state());
        if (KErrNone == error) {
            bufferingComplete();
            doSeek(m_position);
            startPlayback();
#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
            m_downloadStalled = false;
#endif
        }
    } else {
        Q_ASSERT(Phonon::LoadingState == state());
        if (KErrNone == error) {
            updateMetaData();
            changeState(StoppedState);
        } else {
            if (isProgressiveDownload() && KErrCorrupt == error) {
                setProgressiveDownloadStalled();
            } else {
                setError(tr("Loading clip failed"), error);
            }
        }
    }
}

void MMF::AbstractMediaPlayer::playbackComplete(int error)
{
    stopTimers();

    if (KErrNone == error && !m_aboutToFinishSent) {
        const qint64 total = totalTime();
        emit MMF::AbstractPlayer::tick(total);
        m_aboutToFinishSent = true;
        emit aboutToFinish();
    }

    if (KErrNone == error) {
        changeState(PausedState);

        // MediaObject::switchToNextSource deletes the current player, so we
        // call it via delayed slot invokation to ensure that this object does
        // not get deleted during execution of a member function.
        QMetaObject::invokeMethod(m_parent, "switchToNextSource", Qt::QueuedConnection);
    }
    else {
        if (isProgressiveDownload() && KErrCorrupt == error) {
            setProgressiveDownloadStalled();
        } else {
            setError(tr("Playback complete"), error);
            emit finished();
        }
    }
}

qint64 MMF::AbstractMediaPlayer::toMilliSeconds(const TTimeIntervalMicroSeconds &in)
{
    return in.Int64() / 1000;
}

bool MMF::AbstractMediaPlayer::isProgressiveDownload() const
{
#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
    return (0 != m_download);
#else
    return false;
#endif
}

bool MMF::AbstractMediaPlayer::progressiveDownloadStalled() const
{
#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
    return m_downloadStalled;
#else
    return false;
#endif
}

//-----------------------------------------------------------------------------
// Slots
//-----------------------------------------------------------------------------

void MMF::AbstractMediaPlayer::positionTick()
{
    const qint64 pos = getCurrentTime();
    if (pos > m_position) {
        m_position = pos;
        emitMarksIfReached(m_position);
        emit MMF::AbstractPlayer::tick(m_position);
    }
}

void MMF::AbstractMediaPlayer::emitMarksIfReached(qint64 current)
{
    const qint64 total = totalTime();
    const qint64 remaining = total - current;

    if (prefinishMark() && !m_prefinishMarkSent) {
        if (remaining < (prefinishMark() + tickInterval()/2)) {
            m_prefinishMarkSent = true;
            emit prefinishMarkReached(remaining);
        }
    }

    if (!m_aboutToFinishSent) {
        if (remaining < tickInterval()) {
            m_aboutToFinishSent = true;
            emit aboutToFinish();
        }
    }
}

void MMF::AbstractMediaPlayer::resetMarksIfRewound()
{
    const qint64 current = getCurrentTime();
    const qint64 total = totalTime();
    const qint64 remaining = total - current;

    if (prefinishMark() && m_prefinishMarkSent)
        if (remaining >= (prefinishMark() + tickInterval()/2))
            m_prefinishMarkSent = false;

    if (m_aboutToFinishSent)
        if (remaining >= tickInterval())
            m_aboutToFinishSent = false;
}

void MMF::AbstractMediaPlayer::setPending(Pending pending)
{
    const Phonon::State oldState = state();
    m_pending = pending;
    const Phonon::State newState = state();
    if (newState != oldState)
        emit stateChanged(newState, oldState);
}

void MMF::AbstractMediaPlayer::startPlayback()
{
    doPlay();
    startPositionTimer();
    changeState(PlayingState);
}

void MMF::AbstractMediaPlayer::setProgressiveDownloadStalled()
{
#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
    TRACE_CONTEXT(AbstractMediaPlayer::setProgressiveDownloadStalled, EAudioApi);
    TRACE_ENTRY("state %d", state());
    Q_ASSERT(isProgressiveDownload());
    m_downloadStalled = true;
    doClose();
    bufferingStarted();
    // Video player loses window handle when closed - need to reapply it here
    videoOutputChanged();
    m_download->resume();
#endif
}

void MMF::AbstractMediaPlayer::bufferStatusTick()
{
    // During progressive download, there is no way to detect the buffering status.
    // Phonon does not support a "buffering; amount unknown" signal, therefore we
    // return a buffering status of zero.
    const int status = progressiveDownloadStalled() ? 0 : bufferStatus();
    emit MMF::AbstractPlayer::bufferStatus(status);
}

#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
void MMF::AbstractMediaPlayer::downloadLengthChanged(qint64 length)
{
    TRACE_CONTEXT(AbstractMediaPlayer::downloadLengthChanged, EAudioApi);
    TRACE_ENTRY("length %Ld", length);
    Q_UNUSED(length)
    if (m_downloadStalled) {
        bufferingComplete();
        int err = m_parent->openFileHandle(m_download->targetFileName());
        if (KErrNone == err)
            err = openFile(*m_parent->file());
        if (KErrNone != err)
            setError(tr("Error opening file"));
    }
}

void MMF::AbstractMediaPlayer::downloadStateChanged(Download::State state)
{
    TRACE_CONTEXT(AbstractMediaPlayer::downloadStateChanged, EAudioApi);
    TRACE_ENTRY("state %d", state);
    switch (state) {
    case Download::Idle:
    case Download::Initializing:
        break;
    case Download::Downloading:
        {
        int err = m_parent->openFileHandle(m_download->targetFileName());
        if (KErrNone == err)
            err = openFile(*m_parent->file());
        else if (KErrCorrupt == err)
            // Insufficient data downloaded - enter Buffering state
            setProgressiveDownloadStalled();
        if (KErrNone != err)
            setError(tr("Error opening file"));
        }
        break;
    case Download::Complete:
        break;
    case Download::Error:
        setError(tr("Download error"));
        break;
    }
}
#endif // PHONON_MMF_PROGRESSIVE_DOWNLOAD

Phonon::State MMF::AbstractMediaPlayer::phononState(PrivateState state) const
{
    Phonon::State result = AbstractPlayer::phononState(state);

    if (PausePending == m_pending) {
        Q_ASSERT(Phonon::StoppedState == result || Phonon::LoadingState == result);
        result = Phonon::PausedState;
    }

    return result;
}

void MMF::AbstractMediaPlayer::changeState(PrivateState newState)
{
    TRACE_CONTEXT(AbstractMediaPlayer::changeState, EAudioInternal);

    const Phonon::State oldPhononState = phononState(privateState());
    const Phonon::State newPhononState = phononState(newState);

    if (LoadingState == oldPhononState && StoppedState == newPhononState) {
        switch (m_pending) {
        case NothingPending:
            AbstractPlayer::changeState(newState);
            break;

        case PlayPending:
            changeState(PlayingState); // necessary in order to apply initial volume
            doVolumeChanged();
            startPlayback();
            break;

        case PausePending:
            AbstractPlayer::changeState(PausedState);
            break;
        }

        setPending(NothingPending);
    } else {
        AbstractPlayer::changeState(newState);
    }
}

void MMF::AbstractMediaPlayer::updateMetaData()
{
    TRACE_CONTEXT(AbstractMediaPlayer::updateMetaData, EAudioInternal);
    TRACE_ENTRY_0();

    m_metaData.clear();

    const int numberOfEntries = numberOfMetaDataEntries();
    for(int i=0; i<numberOfEntries; ++i) {
        const QPair<QString, QString> entry = metaDataEntry(i);

        // Note that we capitalize the key, as required by the Ogg Vorbis
        // metadata standard to which Phonon adheres:
        // http://xiph.org/vorbis/doc/v-comment.html
        m_metaData.insert(entry.first.toUpper(), entry.second);
    }

    emit metaDataChanged(m_metaData);

    TRACE_EXIT_0();
}

QT_END_NAMESPACE