/*

 * 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.cpp

 *

 */

#include <QMetaType>

#include <QCoreApplication>

#include <QString>

#include <QDebug>

#include <QCoreApplication>

#include "caservice.h"

#include "caservice_p.h"

#include "caquery.h"

#include "caentry.h"

#include "canotifier.h"

#include "canotifier_p.h"

#include "cadefs.h"

#include "caclientproxy.h"

#include "caclientnotifierproxy.h"

#include "cahandlerproxy.h"

#include "caqtsfhandlerloader.h"

#include "caobjectadapter.h"

#include "caclienttest_global.h"

// ======== MEMBER FUNCTIONS ========

/*!

 \class CaService.

 \brief This class operates on data, enables creating and inserting new entry

 to DB, removing entry from DB, update entry or get entry from DB, execute

 command on entry and create notifier to notify a client about changes onto DB.

 CaService class uses singleton design pattern, so that it contains static

 method called instance() to get instance of a class.

 References to CaService instance are counted. When the number of references

 drops to zero the instance is deleted to save memory.

 CaNotifier class contains a member referencing to the CaService instance so

 it is not deleted unless all CaNotifier instances are deleted (and there are

 no variables referencing CaService).

 \code

 QSharedPointer<CaService> service = CaService::instance();

 \endcode

 For every operations on data is used always one instantiation of the class.

 Below, there are examples how to create data and work on those ones.

 */

/*!

 \var CaServicePrivate::m_q

 Points to the CaService instance that uses this private implementation.

 */

/*!

 \var CaServicePrivate::mProxy

 Proxy to communicate with Symbian server.

 */

/*!

 \var CaServicePrivate::mErrorCode

 code of error caused by last operation.

 */

/*!

 \var CaServicePrivate::mNotifierProxy

 Proxy to client notifier.

 */

// Initialization of a static member variable.

QWeakPointer<CaService> CaService::m_instance = QWeakPointer<CaService>();

/*!

 Constructor.

 \param parent pointer to a parent. It defaults to NULL.

 */

CaService::CaService(QObject *parent) :

    QObject(parent), m_d(new CaServicePrivate(this))

{

}

/*!

 Returns a pointer to the instance of the CaService class.

 \retval A pointer to the instance of the CaService class.

 */

QSharedPointer<CaService> CaService::instance()

{

    QSharedPointer<CaService> service(m_instance);

    if (!service) {

        // Register custom types used as types of signal parameters.

        qRegisterMetaType<ChangeType> ("ChangeType");

        qRegisterMetaType<CaEntry> ("CaEntry");

        service = QSharedPointer<CaService>(new CaService);

        m_instance = service.toWeakRef();

        const QString iconEnginesPluginPath("resource/iconengines/plugins");

        QCoreApplication::addLibraryPath(iconEnginesPluginPath);

    }

    return service;

}

/*!

 Destructor.

 */

CaService::~CaService()

{

    delete m_d;

}

/*!

 Search for an entry

 \param entryId id of the entry to find.

 \retval pointer to the found entry.

 \example

 \code

 ...

 CaEntry * entryFromDB = service->getEntry( newItem->id() );

 \endcode

 */

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

{

    QList< QSharedPointer<CaEntry> > entries = getEntries(QList<int> () << entryId);

    if (entries.count()) {

        // there should be exactly one entry with specified ID if present

        Q_ASSERT(entries.count() == 1);

        return entries[0];

    } else {

        return QSharedPointer<CaEntry>();

    }

}

/*!

 Search for entries.

 \param entryIdList list of ids.

 \return list of found entries.

 \example

 \code

 ...

 QList<CaEntry *> entriesFromDB = service->getEntries(

 QList<int>() << newItem->id() << newGroup->id() );

 QList<int> idsList;

 QStringList textEntry;

 CaEntry *entry(NULL);

 foreach( entry, entriesFromDB ) {

 idsList << entry->id();

 textEntry << entry->text();

 }

 \endcode

 */

QList< QSharedPointer<CaEntry> > CaService::getEntries(const QList<int> &entryIdList) const

{

    return m_d->getEntries(entryIdList);

}

/*!

 Search for entries.

 \param query query

 \retval list of entries

 \example

 \code

 ...

 CaQuery query;

 query.setEntryRoles( ItemEntryRole | GroupEntryRole );

 query.setEntryTypeNames( QStringList() << "TypeNameGroup" << "ItemNameGroup" );

 QList<CaEntry *> entriesFromDB = service->getEntries( query );

 QList<int> idsList;

 QStringList typeNames;

 CaEntry *entry(NULL);

 foreach( entry, entriesFromDB ) {

 idsList << entry->id();

 typeNames << entry->entryTypeName();

 }

 \endcode

 */

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

{

    return m_d->getEntries(query);

}

/*!

 Search for entries and return their ids.

 \param query query

 \retval list of ids

 \example

 \code

 ...

 CaQuery query;

 query.setEntryRoles( ItemEntryRole | GroupEntryRole );

 query.setEntryTypeNames( QStringList() << "TypeNameGroup" << "ItemNameGroup" );

 QList<int> entriesIdsFromDB = service->getEntryIds( query );

 QList<int> idsList;

 QStringList typeNames;

 int id( -1 );

 foreach( id, entriesIdsFromDB ) {

 idsList << id

 typeNames << entry->entryTypeName();

 }

 \endcode

 */

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

{

    return m_d->getEntryIds(query);

}

/*!

 Create copy of entry.

 \param entry entry to copy

 \retval pointer to newely created copy

 \example

 \code

 ...

 // creating new entry and add to DB

 CaEntry group( GroupEntryRole );

 group.setText( "TextGroup" );

 group.setTypeName( "TypeNameGroup" );

 CaEntry item( ItemEntryRole );

 item.setText( "TextItem" );

 item.setTypeName( "TypeNameItem" );

 CaEntry * newGroup = service->createEntry( group );

 CaEntry * newItem = service->createEntry( item );

 ...

 \endcode

 */

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

{

    return m_d->createEntry(entry);

}

/*!

 Remove entry.

 \param entryId id of an entry to remove

 \retval true if operation was successful

 \example

 \code

 ...

 bool result = service->removeEntry( newItem->id() );

 \b Output:

 result == true

 \endcode

 */

bool CaService::removeEntry(int entryId) const

{

    return removeEntries(QList<int> () << entryId);

}

/*!

 Remove entries.

 \param entry entry to remove

 \retval true if operation was successful

 \example

 \code

 ...

 bool result = service->removeEntry( *newItem );

 \b Output:

 result == true

 \endcode

 */

bool CaService::removeEntry(const CaEntry &entry) const

{

    return removeEntry(entry.id());

}

/*!

 Remove entries.

 All others are convenience methods implemented in terms of this one.

 \param entryIdList list of ids of entries to remove

 \retval true if operation was successful

 \example

 \code

 ...

 bool result = service->removeEntries( QList<int>() << newItem->id() );

 \b Output:

 result == true

 \endcode

 */

bool CaService::removeEntries(const QList<int> &entryIdList) const

{

    return m_d->removeEntries(entryIdList);

}

/*!

 Remove entries.

 \param entryList list of entries to remove

 \retval true if operation was successful

 \example

 \code

 ...

 bool result = service->removeEntries( QList< QSharedPointer<CaEntry> >() << newItem );

 \b Output:

 result == true

 \endcode

 */

bool CaService::removeEntries(const QList< QSharedPointer<CaEntry> > &entryList) const

{

    QList<int> idList;

    QSharedPointer<CaEntry> entry;

    foreach(entry, entryList) {

        idList << entry->id();

    }

    return removeEntries(idList);

}

/*!

 Update entry.

 \param entry entry to update

 \retval true if operation was successful

 \example

 \code

 ...

 newItem->setAttribute( "attrName", "attrValue" );

 bool result = service->updateEntry( *newItem );

 \b Output:

 result == true

 \endcode

 */

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

{

    return m_d->updateEntry(entry);

}

/*!

 Performs touch operation on entry.

 \param entry of entry to be touched

 \retval boolean with result of operation

 \example

 \code

 ...

 bool result = service->touch( newItem );

 \b Output:

 result == true

 \endcode

 */

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

{

    return m_d->touch(entry);

}

/*!

 Insert entry into a given group.

 \param groupId id of a group.

 \param entryId id of an entry to insert.

 \param beforeEntryId id of an entry before which the given entry is inserted.

 \retval true if operation was successful.

 \example

 \code

 ...

 CaEntry itemToAdd;

 itemToAdd.setText( "TextAdd" );

 itemToAdd.setTypeName( "TypeNameAdd" );

 CaEntry * entryToAdd = service->createEntry( itemToAdd );

 ...

 bool result = service->insertEntryIntoGroup(

 newGroup->id(), entryToAdd->id(), newItem->id());

 \b Output:

 result == true

 \endcode

 */

bool CaService::insertEntryIntoGroup(int groupId, int entryId,

                                     int beforeEntryId) const

{

    return insertEntriesIntoGroup(groupId, QList<int> () << entryId,

                                  beforeEntryId);

}

/*!

 Insert entry into a given group.

 \param group group.

 \param entry entry to insert.

 \param beforeEntryId id of an entry before which the given entry is inserted.

 \retval true if operation was successful.

 \example

 \code

 ...

 CaEntry itemToAdd;

 itemToAdd.setText( "TextAdd" );

 itemToAdd.setTypeName( "TypeNameAdd" );

 CaEntry * entryToAdd = service->createEntry( itemToAdd );

 ...

 bool result = service->insertEntryIntoGroup(

 *newGroup, *entryToAdd, newItem->id());

 \b Output:

 result == true

 \endcode

 */

bool CaService::insertEntryIntoGroup(const CaEntry &group,

                                     const CaEntry &entry, int beforeEntryId) const

{

    return insertEntryIntoGroup(group.id(), entry.id(), beforeEntryId);

}

/*!

 Insert entries into a given group.

 All others are convenience methods implemented in terms of this one.

 \param groupId id of a group.

 \param entryIdList list of ids of entries to insert.

 \param beforeEntryId id of an entry before which the given entry is inserted.

 \retval true if operation was successful.

 \example

 \code

 ...

 CaEntry itemToAdd;

 itemToAdd.setText( "TextAdd" );

 itemToAdd.setTypeName( "TypeNameAdd" );

 CaEntry * entryToAdd = service->createEntry( itemToAdd );

 ...

 bool result = service->insertEntriesIntoGroup(

 newGroup->id(), QList<int>() << entryToAdd->id(), newItem->id());

 \b Output:

 result == true

 \endcode

 */

bool CaService::insertEntriesIntoGroup(int groupId,

                                       const QList<int> &entryIdList, int beforeEntryId) const

{

    if (beforeEntryId < 0) {

        qWarning(

            "CaService::insertEntriesIntoGroup: beforeEntryId cannot be negative: %d",

            beforeEntryId);

        return false;

    } else {

        return m_d->insertEntriesIntoGroup(groupId, entryIdList,

                                           beforeEntryId);

    }

}

/*!

 Insert entry into a given group.

 \param group group.

 \param entryList list of entries (pointers) to insert.

 \param beforeEntryId id of an entry before which the given entry is inserted.

 \retval true if operation was successful.

 \example

 \code

 ...

 CaEntry itemToAdd;

 itemToAdd.setText( "TextAdd" );

 itemToAdd.setTypeName( "TypeNameAdd" );

 CaEntry * entryToAdd = service->createEntry( itemToAdd );

 ...

 bool result = service->insertEntriesIntoGroup(

 *newGroup, QList<CaEntry *>() << entryToAdd, newItem->id());

 \b Output:

 result == true

 \endcode

 */

bool CaService::insertEntriesIntoGroup(const CaEntry &group,

                                       const QList< QSharedPointer<CaEntry> > &entryList, int beforeEntryId) const

{

    QList<int> idList;

    QSharedPointer<CaEntry> entry;

    foreach(entry, entryList) {

        idList << entry->id();

    }

    return insertEntriesIntoGroup(group.id(), idList, beforeEntryId);

}

/*!

 Remove entry from a given group.

 \param groupId id of a group.

 \param entryId id of entry to remove.

 \retval true if operation was successful.

 \example

 \code

 ...

 CaEntry itemToAddRemove;

 itemToAddRemove.setText( "TextAddRemove" );

 itemToAddRemove.setTypeName( "TypeNameAddRemove" );

 CaEntry * entryToAddRemove = service->createEntry( itemToAddRemove );

 service->prependEntryToGroup( *newGroup, *entryToAddRemove );

 ...

 bool result = service->removeEntryFromGroup(

 newGroup->id(), entryToAddRemove->id());

 \b Output:

 result == true

 \endcode

 */

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

{

    return removeEntriesFromGroup(groupId, QList<int> () << entryId);

}

/*!

 Remove entry from a given group.

 \param group group.

 \param entryId id of entry to remove.

 \retval true if operation was successful.

 \example

 \code

 ...

 CaEntry itemToAddRemove;