/*

* 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:                                                         

*

*/

#ifndef XQSERVICETHREADDATA_H

#define XQSERVICETHREADDATA_H

#include "xqservicelog.h"

#include <QtCore/qobject.h>

#include <QtCore/qshareddata.h>

#include <QtCore/qregexp.h>

#include <QMap>

#include <QVariant>

const int CmdRetData = 0xF001 ;

const int CmdErrData = 0xF010 ;

class XQServiceChannel;

class XQServiceIpcClient;

class XQServiceRequestCompletedAsync;

// Special variant class that can perform QDataStream operations

// without the QVariant header information.

class XQServiceVariant : public QVariant

{

public:

    XQServiceVariant() : QVariant() {}

    explicit XQServiceVariant(const QVariant& value)

        : QVariant(value) 

    {

        XQSERVICE_DEBUG_PRINT("XQServiceVariant::XQServiceVariant");

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

    }

    void load(QDataStream& stream, int typeOrMetaType)

    {

        XQSERVICE_DEBUG_PRINT("XQServiceVariant::load");

        clear();

        create(typeOrMetaType, 0);

        d.is_null = false;

        QMetaType::load(stream, d.type, const_cast<void *>(constData()));

    }

    void save(QDataStream& stream) const

    {

        XQSERVICE_DEBUG_PRINT("XQServiceVariant::save");

        QMetaType::save(stream, d.type, constData());

    }

};

class XQServiceChannelPrivate : public QSharedData

{

public:

    XQServiceChannelPrivate(XQServiceChannel *obj, const QString& chan, bool isServer)

        : object(obj), channel(chan), server(isServer)

    {

        XQSERVICE_DEBUG_PRINT("XQServiceChannelPrivate::XQServiceChannelPrivate");        

    }

    XQServiceChannel *object;

    QString channel;

    bool server;

};

typedef QExplicitlySharedDataPointer<XQServiceChannelPrivate> XQServiceChannelPrivatePointer;

typedef QMap<QString, QList<XQServiceChannelPrivatePointer> > XQServiceClientMap;

typedef QMap<QString, XQServiceIpcClient*> XQServiceIpcClientMap;

// Thread-specific data for XQService client and server implementations.

class XQServiceThreadData

{

public:

    XQServiceThreadData()

    {

        XQSERVICE_DEBUG_PRINT("XQServiceThreadData::XQServiceThreadData");

        m_latestError = 0; 

    }

    virtual ~XQServiceThreadData();

    static XQServiceThreadData *instance();

    bool createClientConnection(const QString& channel,bool isServer=false, 

                                bool isSync=true, XQServiceRequestCompletedAsync* rc=NULL,

                               const void *userData=NULL);

    void closeClientConnection(const QString& channel);

    XQServiceIpcClient *clientConnection(const QString& channel);

    // Determine if we have a client connection object for this thread.

    bool hasClientConnection(const QString& ipcConName);

    QString getIpcConnectioName(const QString& channel);

    static QVariant deserializeRetData(const QByteArray &retData);

    static QByteArray serializeRetData(const QVariant &value, int error);

	int latestError();

    void setLatestError(int latestError);

    // Map client-side channel names to lists of XQServiceChannel objects.

    XQServiceClientMap clientMap;

    XQServiceIpcClientMap ipcConnMap;

	int m_latestError;

};

namespace XQService

{

    XQServiceThreadData *serviceThreadData();

}

#endif