/*

 * Copyright (c) 2007 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:

 *

 */

#include <e32std.h>

#include <QList>

#include <QDebug>

#include <QMutexLocker>

#include "caclientproxy.h"

#include "cainnerentry.h"

#include "cainnerquery.h"

#include "caobjectadapter.h"

#include "caentriesarray.h"

#include "caidsarray.h"

#include "cahandlerengine.h"

#include "caarraycleanup.inl"

#include "caentry.h"

#include "caquery.h"

#include "cadefs.h"

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

CaClientProxy::CaClientProxy():

    mHandler(NULL)

{

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

CaClientProxy::~CaClientProxy()

{

    mSession.Close();

    delete mHandler;

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::connect()

{

    int error = mSession.StartServer();

    if (!error) {

        error = mSession.Connect();

    }

    if (error) {

        mSession.Close();

        qWarning("CaClientProxy::connect: error (%d)", error);

    }

    return CaObjectAdapter::convertErrorCode(error);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::addData(const CaEntry &entryToAdd,

    CaEntry &targetEntry)

{

    TRAPD(error, addDataL(entryToAdd, targetEntry));

    USE_QDEBUG_IF(error) << "CaClientProxy::addData - Error ("

        <<  error << ")";

    return CaObjectAdapter::convertErrorCode(error);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::removeData(const QList<int> &entryIdList)

{

    TRAPD(error, removeDataL(entryIdList));

    USE_QDEBUG_IF(error) << "CaClientProxy::removeData - Error ("

        << error << ")";

    return CaObjectAdapter::convertErrorCode(error);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::insertEntriesIntoGroup(int groupId,

    const QList<int> &entryIdList, int beforeEntryId)

{

    TRAPD(error,

        insertEntriesIntoGroupL(groupId, entryIdList, beforeEntryId));

    USE_QDEBUG_IF(error)<< "CaClientProxy::insertEntriesIntoGroup - Error ("

        << error << ")";

    return CaObjectAdapter::convertErrorCode(error);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::removeEntriesFromGroup(int groupId,

    const QList<int> &entryIdList)

{

    TRAPD(error, removeEntriesFromGroupL(groupId, entryIdList));

    USE_QDEBUG_IF(error)<< "CaClientProxy::removeEntriesFromGroup - Error ("

        << error << ")";

    return CaObjectAdapter::convertErrorCode(error);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::getData(const QList<int> &entryIdList,

    QList<CaEntry*> &sourceList)

{

    TRAPD(error, getDataL(entryIdList, sourceList));

    USE_QDEBUG_IF(error) << "CaClientProxy::getData - Error ("

        << error << ")";

    return CaObjectAdapter::convertErrorCode(error);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::getData(const CaQuery &query,

    QList<CaEntry*> &sourceList)

{

    TRAPD(error, getDataL(query, sourceList));

    USE_QDEBUG_IF(error) << "CaClientProxy::getData - Error ("

        << error << ")";

    return CaObjectAdapter::convertErrorCode(error);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::getEntryIds(const CaQuery &query,

    QList<int> &sourceIdList)

{

    TRAPD(error, getEntryIdsL(query, sourceIdList));

    USE_QDEBUG_IF(error) << "CaClientProxy::getEntryIds - Error ("

        << error << ")";

    return CaObjectAdapter::convertErrorCode(error);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::executeCommand(const CaEntry &entry,

    const QString &command)

{

    TRAPD(error, executeCommandL(entry, command));

    USE_QDEBUG_IF(error) << "CaClientProxy::executeCommand - Error ("

        << error << ")";

    return CaObjectAdapter::convertErrorCode(error);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::touch(const CaEntry& aEntry)

{

    TRAPD(error, touchL(aEntry));

    USE_QDEBUG_IF(error) << "CaClientProxy::touch - Error ("

        << error << ")";

    return CaObjectAdapter::convertErrorCode(error);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::customSort(const QList<int> &entryIdList,

        int groupId)

{

    TRAPD(error, customSortL(entryIdList, groupId));

    USE_QDEBUG_IF(error)<< "CaClientProxy::customSort - Error ("

        << error << ")";

    return CaObjectAdapter::convertErrorCode(error);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

void CaClientProxy::addDataL(const CaEntry &entryToAdd,

    CaEntry &targetEntry)

{

    CCaInnerEntry *newEntryToAdd = CCaInnerEntry::NewLC();

    CaObjectAdapter::convertL(entryToAdd, *newEntryToAdd);

    mSession.AddL(*newEntryToAdd);

    CaObjectAdapter::convert(*newEntryToAdd, targetEntry);

    CleanupStack::PopAndDestroy(newEntryToAdd);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

void CaClientProxy::removeDataL(const QList<int> &entryIdList)

{

    RCaIdsArray array;

    CleanupClosePushL(array);

    CaObjectAdapter::convertL(entryIdList, array);

    mSession.RemoveL(array);

    CleanupStack::PopAndDestroy(&array);

}

void CaClientProxy::insertEntriesIntoGroupL(int groupId,

    const QList<int> &entryIdList, int beforeEntryId)

{

    RCaIdsArray array;

    CleanupClosePushL(array);

    CaObjectAdapter::convertL(entryIdList, array);

    TCaOperationParams::OperationType operationType;

    switch (beforeEntryId) {

    case AfterTheLastEntry:

        operationType = TCaOperationParams::EAppend;

        break;

    case BeforeTheFirstEntry:

        operationType = TCaOperationParams::EPrepend;

        break;

    default:

        if (beforeEntryId < 1) {

            qWarning("CaClientProxy::insertEntriesIntoGroupL"

                "- wrong beforeEntryId: (%d)", beforeEntryId);

        }

        operationType = TCaOperationParams::EInsert;

        break;

    }

    TCaOperationParams params = { operationType, groupId, beforeEntryId };

    mSession.OrganizeL(array, params);

    CleanupStack::PopAndDestroy(&array);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

void CaClientProxy::removeEntriesFromGroupL(int groupId,

    const QList<int> &entryIdList)

{

    RCaIdsArray array;

    CleanupClosePushL(array);

    CaObjectAdapter::convertL(entryIdList, array);

    TCaOperationParams params = { TCaOperationParams::ERemove,

        groupId, 0 /*not used*/

    };

    mSession.OrganizeL(array, params);

    CleanupStack::PopAndDestroy(&array);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

void CaClientProxy::getDataL(const QList<int> &entryIdList,

    QList<CaEntry*> &sourceList)

{

    CCaInnerQuery *query = CCaInnerQuery::NewLC();

    RArray<TInt> array;

    CleanupClosePushL(array);

    CaObjectAdapter::convertL(entryIdList, array);

    query->SetIdsL(array);

    RCaEntriesArray results;

    CleanupResetAndDestroyPushL(results);

    mSession.GetListL(*query, results);

    CaObjectAdapter::convertL(results, sourceList);

    CleanupStack::PopAndDestroy(&results);

    CleanupStack::PopAndDestroy(&array);

    CleanupStack::PopAndDestroy(query);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

void CaClientProxy::getDataL(const CaQuery &query,

    QList<CaEntry*> &sourceList)

{

    CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();

    CaObjectAdapter::convertL(query, *innerQuery);

    RCaEntriesArray results;

    CleanupResetAndDestroyPushL(results);

    mSession.GetListL(*innerQuery, results);

    CaObjectAdapter::convertL(results, sourceList);

    CleanupStack::PopAndDestroy(&results);

    CleanupStack::PopAndDestroy(innerQuery);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

void CaClientProxy::getEntryIdsL(const CaQuery &query,

    QList<int> &sourceIdList)

{

    CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();

    CaObjectAdapter::convertL(query, *innerQuery);

    RCaIdsArray results;

    CleanupClosePushL(results);

    mSession.GetEntryIdsL(*innerQuery, results);

    CaObjectAdapter::convertL(results, sourceIdList);

    CleanupStack::PopAndDestroy(&results);

    CleanupStack::PopAndDestroy(innerQuery);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

void CaClientProxy::executeCommandL(const CaEntry &entry,

    const QString &command)

{

    CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();

    CaObjectAdapter::convertL(entry, *innerEntry);

    TPtrC16 commandPtr16(

        reinterpret_cast<const TUint16*> (command.utf16()));

    HBufC8 *convertedCommand = CnvUtfConverter::ConvertFromUnicodeToUtf7L(

        commandPtr16, false);

    CleanupStack::PushL(convertedCommand);

    if (!mHandler) {

        mHandler = CCaHandlerEngine::NewL();

    }

    mHandler->HandleCommandL(*innerEntry, convertedCommand->Des());

    CleanupStack::PopAndDestroy(convertedCommand);

    CleanupStack::PopAndDestroy(innerEntry);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

void CaClientProxy::touchL(const CaEntry& entry)

{

    CCaInnerEntry* innerEntry = CCaInnerEntry::NewLC();

    CaObjectAdapter::convertL(entry, *innerEntry);    

    mSession.TouchL(*innerEntry);

    CleanupStack::PopAndDestroy(innerEntry);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

void CaClientProxy::customSortL(const QList<int> &entryIdList, int groupId)

{

    RCaIdsArray array;

    CleanupClosePushL(array);

    CaObjectAdapter::convertL(entryIdList, array);

    mSession.CustomSortL(array, groupId);

    CleanupStack::PopAndDestroy(&array);

}