/*

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

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description: caservice.h

 *

 */

#ifndef CASERVICE_H

#define CASERVICE_H

#include <QObject>

#include <QSharedPointer>

#include <QMetaType>

#include <QCoreApplication>

#include <QString>

#include <QDebug>

#include "caservice.h"

#include "caquery.h"

#include "caentry.h"

#include "canotifier.h"

#include "canotifierfilter.h"

#include "cadefs.h"

typedef QList< QSharedPointer<CaEntry> > CaEntryList;

// mocks Content Storage's CaService

class CaService: public QObject

{

    Q_OBJECT

    explicit CaService(QObject *parent = 0);

    ~CaService();

public:

    static QSharedPointer<CaService> instance();

    // mock only those methods of original CaService that are used in the module

    QSharedPointer<CaEntry> getEntry(int entryId) const;

    QList< QSharedPointer<CaEntry> > getEntries(const CaQuery &query) const;

    QList<int> getEntryIds(const CaQuery &query) const;

    QSharedPointer<CaEntry> createEntry(const CaEntry &entry) const;

    bool removeEntry(int entryId) const;

    bool updateEntry(const CaEntry &entry) const;

    bool touch(const CaEntry &entry) const;

    bool removeEntryFromGroup(int groupId, int entryId) const;

    bool appendEntryToGroup(int groupId, int entryId) const;

    bool appendEntriesToGroup(int groupId,

        const QList<int> &entryIdList) const;

    int executeCommand(int entryId, const QString &command = 

        caCmdOpen, QObject* receiver = NULL, const char* member = NULL) const;

    int executeCommand(const CaEntry &entry, const QString &command =

        caCmdOpen, QObject* receiver = NULL, const char* member = NULL) const;

    bool customSort(int groupId, QList<int> &entryIdList) const;

    CaNotifier * createNotifier(const CaNotifierFilter &filter) const;

    mutable int mGetEntryId;

    mutable QSharedPointer<CaEntry> mGetEntryResult;

    mutable CaQuery mGetEntriesQuery;

    mutable QList< QSharedPointer<CaEntry> > mGetEntriesResult;

    mutable CaQuery mGetEntryIdQuery;

    mutable QList<int> mGetEntryIdsResult;

    mutable CaEntry mCreatedEntry;

    mutable QSharedPointer<CaEntry>mCreateEntryResult;

    mutable int mRemoveEntryId;

    mutable bool mRemoveEntryForIdResult;

    mutable CaEntry mUpdateEntry;

    mutable bool mUpdateEntryResult;

    mutable CaEntry mTouchEntry;

    mutable QList<int> mTouchEntriesId;

    mutable bool mTouchResult;

    mutable int mRemoveGroupId;

    mutable int mRemoveEntryFromGroupId;

    mutable bool mRemoveEntryFromGroupResult;

    mutable int mAppendGroupId;

    mutable int mAppenEntryId;

    mutable bool mAppendEntryToGroupResult;

    mutable int mAppendListGroupId;

    mutable QList<int> mAppendEntryIdList;

    mutable bool mAppendEntriesToGroupResult;

    mutable int mExecuteEntryId;

    mutable QString mExecuteCommand;

    mutable int mExecuteCommandResult;

    mutable CaEntry mExecuteEntry;

    mutable int mCustomSortGroupId;

    mutable QList<int> mCustomSortEntryIdList;

    mutable bool mCustomSortResult;

    mutable CaNotifierFilter mCreateNotifierFilter;

    mutable CaNotifier *mCreateNotifierResult;

    // helper for tests, not belonging to CaService

    void clear()

    {

        mGetEntryId = 0;

        mGetEntryResult.clear();

        mGetEntriesQuery.clear();

        mGetEntriesResult.clear();

        mGetEntryIdQuery.clear();

        mGetEntryIdsResult.clear();

        mCreatedEntry.clear();

        mCreateEntryResult.clear();

        mRemoveEntryId = 0;

        mRemoveEntryForIdResult = false;

        mUpdateEntry.clear();

        mUpdateEntryResult = false;

        mTouchEntry.clear();

        mTouchEntriesId.clear();

        mTouchResult = false;

        mRemoveGroupId = 0;

        mRemoveEntryFromGroupId = 0;

        mRemoveEntryFromGroupResult = false;

        mAppendGroupId = 0;

        mAppenEntryId = 0;

        mAppendEntryToGroupResult = false;

        mAppendListGroupId = 0;

        mAppendEntryIdList.clear();

        mAppendEntriesToGroupResult = false;

        mExecuteEntryId = 0;

        mExecuteCommand.clear();

        mExecuteCommandResult = -333;

        mCustomSortGroupId = 0;

        mCustomSortEntryIdList.clear();

        mCustomSortResult = false;

        mCreateNotifierFilter = CaNotifierFilter();

        mCreateNotifierResult = 0;

    }

private:

    Q_DISABLE_COPY(CaService)

    friend class QtSharedPointer::ExternalRefCount<CaService>;

};

inline CaService::CaService(QObject *parent) :

        QObject(parent),

        mGetEntryId(0),

        mRemoveEntryId(0),

        mRemoveEntryForIdResult(false),

        mUpdateEntryResult(false),

        mTouchResult(false),

        mRemoveGroupId(0),

        mRemoveEntryFromGroupId(0),

        mRemoveEntryFromGroupResult(false),

        mAppendGroupId(0),

        mAppenEntryId(0),

        mAppendEntryToGroupResult(false),

        mAppendListGroupId(0),

        mAppendEntriesToGroupResult(false),

        mExecuteEntryId(0),

        mExecuteCommandResult(false),

        mCustomSortGroupId(0),

        mCustomSortResult(false),

        mCreateNotifierResult(0)

{

}

inline QSharedPointer<CaService> CaService::instance()

{

    static QSharedPointer<CaService> service(new CaService);

    return service;

}

inline CaService::~CaService()

{

}

inline QSharedPointer<CaEntry> CaService::getEntry(int entryId) const

{

    mGetEntryId = entryId;

    if (!mGetEntryResult.isNull()) {

        mGetEntryResult->mIdResult = entryId;

    }

    return mGetEntryResult;

}

inline QList< QSharedPointer<CaEntry> > CaService::getEntries(const CaQuery &query) const

{

    mGetEntriesQuery = query;

    return mGetEntriesResult;

}

inline QList<int> CaService::getEntryIds(const CaQuery &query) const

{

    mGetEntryIdQuery = query;

    return mGetEntryIdsResult;

}

inline QSharedPointer<CaEntry> CaService::createEntry(const CaEntry &entry) const

{

    mCreatedEntry = entry;

    return mCreateEntryResult;

}

inline bool CaService::removeEntry(int entryId) const

{

    mRemoveEntryId = entryId;

    return mRemoveEntryForIdResult;

}

inline bool CaService::updateEntry(const CaEntry &entry) const

{

    mUpdateEntry = entry;

    return mUpdateEntryResult;

}

inline bool CaService::touch(const CaEntry &entry) const

{

    if (entry.flags() & RemovableEntryFlag &&

        (entry.flags() & UsedEntryFlag) == 0 &&

        entry.role() == ItemEntryRole &&

        entry.entryTypeName() != QString("package")) { //packageTypeName

        mTouchEntry = entry;

        mTouchEntriesId.append(entry.id());

        return mTouchResult;

    } else {

        return true;

    }

}

inline bool CaService::removeEntryFromGroup(int groupId, int entryId) const

{

    mRemoveGroupId = groupId;

    mRemoveEntryFromGroupId = entryId;

    return mRemoveEntryFromGroupResult;

}

inline bool CaService::appendEntryToGroup(int groupId, int entryId) const

{

    mAppendGroupId = groupId;

    mAppenEntryId = entryId;

    return mAppendEntryToGroupResult;

}

inline bool CaService::appendEntriesToGroup(int groupId,

                                     const QList<int> &entryIdList) const

{

    mAppendListGroupId = groupId;

    mAppendEntryIdList = entryIdList;

    return mAppendEntriesToGroupResult;

}

inline int CaService::executeCommand(int entryId, const QString &command, 

        QObject* receiver, const char* member) const

{

    Q_UNUSED(receiver);

    Q_UNUSED(member);

    mExecuteEntryId = entryId;

    mExecuteCommand = command;

    return mExecuteCommandResult;

}

inline int CaService::executeCommand(const CaEntry &entry, const QString &command, 

        QObject* receiver, const char* member) const

{

    Q_UNUSED(receiver);

    Q_UNUSED(member);

    mExecuteEntry = entry;

    mExecuteCommand = command;

    return mExecuteCommandResult;

}

inline bool CaService::customSort(int groupId, QList<int> &entryIdList) const

{

    mCustomSortGroupId = groupId;

    mCustomSortEntryIdList = entryIdList;

    return mCustomSortResult;

}

inline CaNotifier * CaService::createNotifier(const CaNotifierFilter &filter) const

{

    mCreateNotifierFilter = filter;

    return mCreateNotifierResult;

}

#endif // CASERVICE_H