/*

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

* All rights reserved.

*

* This program 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, version 2.1 of the License.

* 

* This program 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 program.  If not, 

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:                                                         

*

*/                                                                    

#include "xqservicelog.h"

#include "xqserviceglobal.h"

#include "xqserviceadaptor.h"

#include "xqservicechannel.h"

#include "xqservicethreaddata.h"

#include "xqserviceipcclient.h"

#include <xqserviceutil.h>

#include <xqrequestutil.h>

#include <qmetaobject.h>

#include <QMap>

#include <QDataStream>

#include <qatomic.h>

#include <QDebug>

#include <QVarLengthArray>

#include <e32err.h>

#include <xqsharablefile.h>

/*!

    \class XQServiceAdaptor

    \inpublicgroup QtBaseModule

    \ingroup ipc

    \brief The XQServiceAdaptor class provides an interface to messages on a XQService IPC channel which simplifies remote signal and slot invocations.

    Using this class, it is very easy to convert a signal emission into an IPC

    message on a channel, and to convert an IPC message on a channel into a

    slot invocation.  In the following example, when the signal \c{valueChanged(int)}

    is emitted from the object \c source, the IPC message \c{changeValue(int)} will

    be sent on the channel \c{QPE/Foo}:

    \code

    XQServiceAdaptor *adaptor = new XQServiceAdaptor("QPE/Foo");

    XQServiceAdaptor::connect

        (source, SIGNAL(valueChanged(int)), adaptor, MESSAGE(changeValue(int)));

    \endcode

    Note that we use XQServiceAdaptor::connect() to connect the signal to the

    IPC message, not QObject::connect().  A common error is to use \c{connect()}

    without qualifying it with \c{XQServiceAdaptor::} and picking up

    QObject::connect() by mistake.

    On the server side of an IPC protocol, the \c{changeValue(int)} message can

    be connected to the slot \c{setValue()} on \c dest:

    \code

    XQServiceAdaptor *adaptor = new XQServiceAdaptor("QPE/Foo");

    XQServiceAdaptor::connect

        (adaptor, MESSAGE(changeValue(int)), dest, SLOT(setValue(int)));

    \endcode

    Now, whenever the client emits the \c{valueChanged(int)} signal, the

    \c{setValue(int)} slot will be automatically invoked on the server side,

    with the \c int parameter passed as its argument.

    Only certain parameter types can be passed across an IPC boundary in this fashion.

    The type must be visible to QVariant as a meta-type.  Many simple built-in

    types are already visible; for user-defined types, use Q_DECLARE_METATYPE()

    and qRegisterMetaTypeStreamOperators().

    \sa XQServiceChannel

*/

class XQServiceAdaptorChannel : public XQServiceChannel

{

    Q_OBJECT

public:

    XQServiceAdaptorChannel(const QString& channel, XQServiceAdaptor *adapt)

        : XQServiceChannel(channel, true, adapt), adaptor(adapt) 

    {

        XQSERVICE_DEBUG_PRINT("XQServiceAdaptorChannel::XQServiceAdaptorChannel");

    }

    ~XQServiceAdaptorChannel() 

    {

        XQSERVICE_DEBUG_PRINT("XQServiceAdaptorChannel::~XQServiceAdaptorChannel");

    }

    QVariant receive(const QString& msg, const QByteArray &data, const XQSharableFile &sf);

    void commandReceive(const XQServiceCommand cmd);

private slots:

private:

    XQServiceAdaptor *adaptor;

};

QVariant XQServiceAdaptorChannel::receive(const QString& msg, const QByteArray &data, const XQSharableFile &sf)

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptorChannel::receive");

    return adaptor->received(msg, data, sf);

}

void XQServiceAdaptorChannel::commandReceive(const XQServiceCommand cmd)

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptorChannel::commandReceive %d", cmd);

    switch (cmd)

    {

        case ReturnValueDelivered:

            emit adaptor->returnValueDelivered() ;

            break;

        case ClientDisconnected:

            emit adaptor->clientDisconnected() ;

            break;

        default:

            XQSERVICE_DEBUG_PRINT("XQServiceAdaptorChannel::unhandled command %d", cmd);

        break;

    }

}

class XQServiceAdaptorSignalInfo

{

public:

    QObject *sender;

    int signalIndex;

    int destroyIndex;

    QString message;

    int *types;

    int numArgs;

};

class XQServiceAdaptorSlotInfo

{

public:

    ~XQServiceAdaptorSlotInfo()

    {

        XQSERVICE_DEBUG_PRINT("XQServiceAdaptorSlotInfo::~XQServiceAdaptorSlotInfo");

        qFree(types);

    }

    QObject *receiver;

    int memberIndex;

    bool destroyed;

    int returnType;

    int *types;

    int numArgs;

};

class XQServiceAdaptorPrivate : public QObject

{

    // Do not put Q_OBJECT here.

public:

    XQServiceAdaptorPrivate(XQServiceAdaptor *obj, const QString& chan);

    ~XQServiceAdaptorPrivate();

    QAtomicInt ref;

    XQServiceAdaptor *parent;

    QString channelName;

    bool connected;

    const QMetaObject *publishedTo;

    QMultiMap<QString, XQServiceAdaptorSlotInfo *> invokers;

    QList<XQServiceAdaptorSignalInfo *> signalList;

    int slotIndex;

    static const int QVariantId = -243;

    static int *connectionTypes(const QByteArray& member, int& nargs);

    static int typeFromName(const QByteArray& name);

protected:

    int qt_metacall(QMetaObject::Call c, int id, void **a);

};

XQServiceAdaptorPrivate::XQServiceAdaptorPrivate(XQServiceAdaptor *obj, const QString& chan)

    : ref(1), channelName(chan)

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptorPrivate::XQServiceAdaptorPrivate");

    parent = obj;

    connected = false;

    publishedTo = 0;

    // Fake slots start at this index in the QMetaObject.

    slotIndex = staticMetaObject.methodCount();

}

XQServiceAdaptorPrivate::~XQServiceAdaptorPrivate()

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptorPrivate::~XQServiceAdaptorPrivate");

    qDeleteAll(invokers);

    // Disconnect all of the signals associated with this adaptor.

    int index = slotIndex;

    XQSERVICE_DEBUG_PRINT("index: %d", index);

    foreach (XQServiceAdaptorSignalInfo *info, signalList) {

        XQSERVICE_DEBUG_PRINT("info->signalIndex: %d", info->signalIndex);

        if (info->signalIndex >= 0) {

            QMetaObject::disconnect(info->sender, info->signalIndex,

                                    this, index);

        }

        XQSERVICE_DEBUG_PRINT("info->destroyIndex: %d", info->destroyIndex);

        if (info->destroyIndex >= 0) {

            QMetaObject::disconnect(info->sender, info->destroyIndex,

                                    this, index + 1);

        }

        qFree(info->types);

        delete info;

        index += 2;

    }

}

// Get the QVariant type number for a type name.

int XQServiceAdaptorPrivate::typeFromName( const QByteArray& type )

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptorPrivate::typeFromName");

    XQSERVICE_DEBUG_PRINT("type: %s", type.constData());

    if (type.endsWith('*')){

        XQSERVICE_DEBUG_PRINT("Pointer");

        return QMetaType::VoidStar;

    }

    else if ( type.size() == 0 || type == "void" ){

        XQSERVICE_DEBUG_PRINT("Void");

        return QMetaType::Void;

    }

    else if ( type == "QVariant" ){

        XQSERVICE_DEBUG_PRINT("QVariant");

        return XQServiceAdaptorPrivate::QVariantId;

    }

    int id = QMetaType::type( type.constData() );

    XQSERVICE_DEBUG_PRINT("id: %d", id);

    if ( id != (int)QMetaType::Void )

        return id;

    return QVariant::nameToType(type);

}

// Returns the connection types associated with a signal or slot member.

int *XQServiceAdaptorPrivate::connectionTypes( const QByteArray& member, int& nargs )

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptorPrivate::connectionTypes");

    XQSERVICE_DEBUG_PRINT("member: %s", member.constData());

    // Based on Qt's internal queuedConnectionTypes function.

    nargs = 0;

    int *types = 0;

    const char *s = member.constData();

    while (*s != '\0' && *s != '(') { ++s; }

    if ( *s == '\0' )

        return 0;

    ++s;

    const char *e = s;

    while (*e != ')') {

        ++e;

        if (*e == ')' || *e == ',')

            ++nargs;

    }

    types = (int *) qMalloc((nargs+1)*sizeof(int));

    types[nargs] = 0;

    for (int n = 0; n < nargs; ++n) {

        e = s;

        while (*s != ',' && *s != ')')

            ++s;

        QByteArray type(e, s-e);

        ++s;

        types[n] = typeFromName(type);

        if (!types[n]) {

            XQSERVICE_WARNING_PRINT("XQServiceAdaptorPrivate::connectionTypes: Cannot marshal arguments of type '%s'", type.constData());

            qFree(types);

            return 0;

        }

    }

    XQSERVICE_DEBUG_PRINT("types: %d", types);

    return types;

}

int XQServiceAdaptorPrivate::qt_metacall(QMetaObject::Call c, int id, void **a)

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptorPrivate::qt_metacall");

    id = QObject::qt_metacall(c, id, a);

    XQSERVICE_DEBUG_PRINT("id: %d", id);

    if (id < 0)

        return id;

    if (c == QMetaObject::InvokeMetaMethod) {

        XQSERVICE_DEBUG_PRINT("InvokeMetaMethod");

        // Each signal that we have intercepted has two fake slots

        // associated with it.  The first is the activation slot.

        // The second is the destroyed() slot for the signal's object.

        if (id < signalList.size() * 2) {

            XQServiceAdaptorSignalInfo *info = signalList[id / 2];

            if ((id % 2) == 0) {

                // The signal we are interested in has been activated.

                if (info->types) {

                    XQSERVICE_DEBUG_PRINT("Signal has been activated");

                    QList<QVariant> args;

                    XQSERVICE_DEBUG_PRINT("info->numArgs: %d", info->numArgs);

                    for (int i = 0; i < info->numArgs; ++i) {

                        if (info->types[i] != XQServiceAdaptorPrivate::QVariantId) {

                            QVariant arg(info->types[i], a[i + 1]);

                            XQSERVICE_DEBUG_PRINT("arg: %s", qPrintable(arg.toString()));

                            args.append(arg);

                        } else {

                            args.append(*((const QVariant *)(a[i + 1])));

                        }

                    }

                    //TODO: CHECK HERE

                    QVariant retValue;

                    parent->sendMessage(info->message, args,retValue);

                }

            } else {

                XQSERVICE_DEBUG_PRINT("Sender has been destroyed");

                // The sender has been destroyed.  Clear the signal indices

                // so that we don't try to do a manual disconnect when our

                // own destructor is called.

                info->signalIndex = -1;

                info->destroyIndex = -1;

            }

        }

        id -= signalList.size() * 2;

    }

    XQSERVICE_DEBUG_PRINT("id: %d", id);

    return id;

}

/*!

    Construct a Qt Extended IPC message object for \a channel and attach it to \a parent.

    If \a channel is empty, then messages are taken from the application's

    \c{appMessage} channel.

*/

XQServiceAdaptor::XQServiceAdaptor(const QString& channel, QObject *parent)

    : QObject(parent)

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptor::XQServiceAdaptor");

    d = new XQServiceAdaptorPrivate(this, channel);

}

/*!

*/

XQServiceAdaptor::~XQServiceAdaptor()

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptor::~XQServiceAdaptor");

    if (!d->ref.deref())

        delete d;

    d = 0;

}

/*!

    Returns the name of the channel that this adaptor is associated with.

*/

QString XQServiceAdaptor::channel() const

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptor::channel");

    XQSERVICE_DEBUG_PRINT("d->channelName: %s", qPrintable(d->channelName));

    return d->channelName;

}

/*!

    Connects \a signal on \a sender to \a member on \a receiver.  Returns true

    if the receiveion was possible; otherwise returns false.

    If either \a sender or \a receiver are instances of

    XQServiceAdaptor, this function will arrange for the signal

    to be delivered over a Qt Extended IPC channel.  If both \a sender and

    \a receiver are local, this function is identical

    to QObject::connect().

    If the same signal is connected to same slot multiple times,

    then signal delivery will happen that many times.

    \sa XQServiceAdaptor::ChannelSelector

*/

bool XQServiceAdaptor::connect(QObject *sender, const QByteArray& signal,

                          QObject *receiver, const QByteArray& member)

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptor::connect");

    XQSERVICE_DEBUG_PRINT("signal: %s", signal.constData());

    XQSERVICE_DEBUG_PRINT("member: %s", member.constData());

    XQServiceAdaptor *senderProxy;

    XQServiceAdaptor *receiverProxy;

    // Bail out if the parameters are invalid.

    if (!sender || signal.isEmpty() || !receiver || member.isEmpty()){

        XQSERVICE_DEBUG_PRINT("Parameters are invalid");

        return false;

    }

    // Resolve the objects to find the remote proxies.

    senderProxy = qobject_cast<XQServiceAdaptor *>(sender);

    receiverProxy = qobject_cast<XQServiceAdaptor *>(receiver);

    // Remove proxies if the signal or member is not tagged with MESSAGE().

    if (!member.startsWith(QMESSAGE_CODE + '0')){

        XQSERVICE_DEBUG_PRINT("No received proxy");

        receiverProxy = 0;

    }

    if (!signal.startsWith(QMESSAGE_CODE + '0')){

        XQSERVICE_DEBUG_PRINT("No sender proxy");

        senderProxy = 0;

    }

    // If neither has a proxy, then use a local connect.

    if (!senderProxy && !receiverProxy){

        XQSERVICE_DEBUG_PRINT("Local connect");

        return QObject::connect(sender, signal, receiver, member);

    }

    // If both are still remote proxies, then fail the request.

    if (senderProxy && receiverProxy) {

        XQSERVICE_WARNING_PRINT("XQServiceAdaptor::connect: cannot connect MESSAGE() to MESSAGE()");

        return false;

    }

    // Determine which direction the connect needs to happen in.

    if (receiverProxy) {

        XQSERVICE_DEBUG_PRINT("Connecting a local signal to a remote slot");

        // Connecting a local signal to a remote slot.

        return receiverProxy->connectLocalToRemote(sender, signal, member);

    } else {

        XQSERVICE_DEBUG_PRINT("Connecting a remote signal to a local slot");

        // Connecting a remote signal to a local slot.

        return senderProxy->connectRemoteToLocal(signal, receiver, member);

    }

}

/*!

    Publishes the signal or slot called \a member on this object on

    the Qt Extended IPC channel represented by this XQServiceAdaptor.

    If \a member is a slot, then whenever an application sends a

    message to the channel with that name, the system will arrange

    for the slot to be invoked.

    If \a member is a signal, then whenever this object emits that

    signal, the system will arrange for a message with that name to

    be sent on the channel.

    Returns false if \a member does not refer to a valid signal or slot.

    \sa publishAll()

*/

bool XQServiceAdaptor::publish(const QByteArray& member)

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptor::publish");

    XQSERVICE_DEBUG_PRINT("member: %s", member.constData());

    // '1' is QSLOT_CODE in Qt 4.4 and below,

    // '5' is QSLOT_CODE in Qt 4.5 and higher.

    if (member.size() >= 1 && (member[0] == '1' || member[0] == '5')) {

        XQSERVICE_DEBUG_PRINT("Exporting a slot");

        // Exporting a slot.

        return connectRemoteToLocal("3" + member.mid(1), this, member);

    } else {

        XQSERVICE_DEBUG_PRINT("Exporting a sigal");

        // Exporting a signal.

        return connectLocalToRemote(this, member, member);

    }

}

/*!

    \enum XQServiceAdaptor::PublishType

    Type of members to publish via XQServiceAdaptor.

    \value Signals Publish only signals.

    \value Slots Publish only public slots.

    \value SignalsAndSlots Publish both signals and public slots.

*/

/*!

    Publishes all signals or public slots on this object within subclasses of

    XQServiceAdaptor.  This is typically called from a subclass constructor.

    The \a type indicates if all signals, all public slots, or both, should

    be published.  Private and protected slots will never be published.

    \sa publish()

*/

void XQServiceAdaptor::publishAll(XQServiceAdaptor::PublishType type)

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptor::publishAll(1)");

    publishAll(this,XQServiceAdaptor::staticMetaObject.methodCount(),type);

}

void XQServiceAdaptor::publishAll(QObject* object,int metCount, XQServiceAdaptor::PublishType type)

{

    XQSERVICE_DEBUG_PRINT("XQServiceAdaptor::publishAll(2)");

    XQSERVICE_DEBUG_PRINT("metCount: %d", metCount);

    const QMetaObject *meta = object->metaObject();

    if (meta != d->publishedTo) {

        int count = meta->methodCount();

        XQSERVICE_DEBUG_PRINT("count: %d", count);

        int index;

        if (d->publishedTo)

            index = d->publishedTo->methodCount();

        else

            index = metCount;

        XQSERVICE_DEBUG_PRINT("index: %d", index);

        for (; index < count; ++index) {

            QMetaMethod method = meta->method(index);

            if (method.methodType() == QMetaMethod::Slot &&

                 method.access() == QMetaMethod::Public &&

                 (type == Slots || type == SignalsAndSlots)) {

                QByteArray name = method.signature();

                XQSERVICE_DEBUG_PRINT("name: %s", name.constData());

                XQSERVICE_DEBUG_PRINT("connectRemoteToLocal");

                connectRemoteToLocal("3" + name, object, "1" + name);

            } else if (method.methodType() == QMetaMethod::Signal &&

                        (type == Signals || type == SignalsAndSlots)) {

                QByteArray name = method.signature();

                XQSERVICE_DEBUG_PRINT("name: %s", name.constData());

                XQSERVICE_DEBUG_PRINT("connectLocalToRemote");

                connectLocalToRemote(object, "2" + name, "3" + name);

            }

        }

        d->publishedTo = meta;

    }

}

/*!

    Sends a message on the Qt Extended IPC channel which will cause the invocation