/*  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 <QStringList>
#include <QtPlugin>

#include <apgcli.h> // for RApaLsSession
#include <apmrec.h> // for CDataTypeArray
#include <apmstd.h> // for TDataType

#include "abstractaudioeffect.h"
#include "audiooutput.h"
#include "audioplayer.h"
#include "backend.h"
#include "effectfactory.h"
#include "mediaobject.h"
#include "utils.h"
#include "videowidget.h"

QT_BEGIN_NAMESPACE

using namespace Phonon;
using namespace Phonon::MMF;

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

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

Backend::Backend(QObject *parent)   : QObject(parent)
{
    TRACE_CONTEXT(Backend::Backend, EBackend);
    TRACE_ENTRY_0();

    setProperty("identifier",     QLatin1String("phonon_mmf"));
    setProperty("backendName",    QLatin1String("MMF"));
    setProperty("backendComment", QLatin1String("Backend using Symbian Multimedia Framework (MMF)"));
    setProperty("backendVersion", QLatin1String("0.1"));
    setProperty("backendWebsite", QLatin1String("http://qt.nokia.com/"));

    TRACE_EXIT_0();
}

QObject *Backend::createObject(BackendInterface::Class c, QObject *parent, const QList<QVariant> &args)
{
    TRACE_CONTEXT(Backend::createObject, EBackend);
    TRACE_ENTRY("class %d", c);

    QObject* result = 0;

    switch (c) {
    case AudioOutputClass:
        result = new AudioOutput(this, parent);
        break;

    case MediaObjectClass:
        result = new MediaObject(parent);
        break;

    case VolumeFaderEffectClass:
    case VisualizationClass:
    case VideoDataOutputClass:
    case EffectClass:
    {
        Q_ASSERT(args.count() == 1);
        Q_ASSERT(args.first().type() == QVariant::Int);
        const AbstractAudioEffect::Type effect = AbstractAudioEffect::Type(args.first().toInt());

        return EffectFactory::createAudioEffect(effect, parent);
    }
    case VideoWidgetClass:
        result = new VideoWidget(qobject_cast<QWidget *>(parent));
        break;

    default:
        TRACE_PANIC(InvalidBackendInterfaceClass);
    }

    TRACE_RETURN("0x%08x", result);
}

QList<int> Backend::objectDescriptionIndexes(ObjectDescriptionType type) const
{
    TRACE_CONTEXT(Backend::objectDescriptionIndexes, EAudioApi);
    TRACE_ENTRY_0();
    QList<int> retval;

    switch(type)
    {
        case EffectType:
            retval.append(EffectFactory::effectIndexes());
            break;
        case AudioOutputDeviceType:
            // We only have one possible output device, but we need at least
            // one.
            retval.append(AudioOutput::AudioOutputDeviceID);
            break;
        default:
            ;
    }

    TRACE_EXIT_0();
    return retval;
}

QHash<QByteArray, QVariant> Backend::objectDescriptionProperties(ObjectDescriptionType type, int index) const
{
    TRACE_CONTEXT(Backend::connectNodes, EBackend);

    switch (type) {
        case EffectType:
            return EffectFactory::audioEffectDescriptions(AbstractAudioEffect::Type(index));
        case AudioOutputDeviceType:
            return AudioOutput::audioOutputDescription(index);
        default:
            return QHash<QByteArray, QVariant>();
    }
}

bool Backend::startConnectionChange(QSet<QObject *>)
{
    return true;
}

bool Backend::connectNodes(QObject *source, QObject *target)
{
    TRACE_CONTEXT(Backend::connectNodes, EBackend);
    TRACE_ENTRY("source 0x%08x target 0x%08x", source, target);
    Q_ASSERT(qobject_cast<MediaNode *>(source));
    Q_ASSERT(qobject_cast<MediaNode *>(target));

    MediaNode *const mediaSource = static_cast<MediaNode *>(source);
    MediaNode *const mediaTarget = static_cast<MediaNode *>(target);

    return mediaSource->connectMediaNode(mediaTarget);
}

bool Backend::disconnectNodes(QObject *source, QObject *target)
{
    TRACE_CONTEXT(Backend::disconnectNodes, EBackend);
    TRACE_ENTRY("source 0x%08x target 0x%08x", source, target);
    Q_ASSERT(qobject_cast<MediaNode *>(source));
    Q_ASSERT(qobject_cast<MediaNode *>(target));

    const bool result = static_cast<MediaNode *>(source)->disconnectMediaNode(static_cast<MediaNode *>(target));

    TRACE_RETURN("%d", result);
}

bool Backend::endConnectionChange(QSet<QObject *>)
{
    return true;
}

void getAvailableMimeTypesL(QStringList& result)
{
    RApaLsSession apaSession;
    User::LeaveIfError(apaSession.Connect());
    CleanupClosePushL(apaSession);

    static const TInt DataTypeArrayGranularity = 8;
    CDataTypeArray* array = new(ELeave) CDataTypeArray(DataTypeArrayGranularity);
    CleanupStack::PushL(array);

    apaSession.GetSupportedDataTypesL(*array);

    for (TInt i = 0; i < array->Count(); ++i) {
        const TPtrC mimeType = array->At(i).Des();
        const MediaType mediaType = Utils::mimeTypeToMediaType(mimeType);
        if (MediaTypeAudio == mediaType or MediaTypeVideo == mediaType) {
            result.append(qt_TDesC2QString(mimeType));
        }
    }

    CleanupStack::PopAndDestroy(2); // apaSession, array
}

QStringList Backend::availableMimeTypes() const
{
    QStringList result;

    // There is no way to return an error from this function, so we just
    // have to trap and ignore exceptions...
    TRAP_IGNORE(getAvailableMimeTypesL(result));

    result.sort();

    return result;
}

Q_EXPORT_PLUGIN2(phonon_mmf, Phonon::MMF::Backend);

QT_END_NAMESPACE