/*

* Copyright (c) 2008 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 "conversationsengine_p.h"

//SYSTEM INCLUDES

#include <ccsconversationentry.h>

#include <ccsclientconversation.h>

//USER INCLUDES

#include "conversationsenginedefines.h"

#include "conversationmsgstorehandler.h"

#include "conversationssummarymodel.h"

#include "conversationsmodel.h"

#include "conversationchangehandler.h"

#include "conversationlistchangehandler.h"

#include "debugtraces.h"

//CONSTANTS

/**

 *Max number of conversation that can be exchanged in IPC call

 */

const TInt KMaxConversationIPCLimit =  250;

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

// ConversationsEnginePrivate::ConversationsEnginePrivate

// @see header

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

ConversationsEnginePrivate::ConversationsEnginePrivate(

    ConversationMsgStoreHandler* conversationMsgStoreHandler,

    ConversationsSummaryModel *conversationsSummaryModel,

    ConversationsModel *conversationsModel

    ):mServer(NULL),

    mClientConv(NULL),

    mConversationMsgStoreHandler(conversationMsgStoreHandler),

    mConversationsSummaryModel(conversationsSummaryModel),

    mConversationsModel(conversationsModel)

{

        initL();

}

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

// ConversationsEnginePrivate::~ConversationsEnginePrivate

// @see header

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

ConversationsEnginePrivate::~ConversationsEnginePrivate()

{

    if( mClientConv )

    {        

        if(mServer && mConvChangeHandler)

        {    

        TRAP_IGNORE(mServer->RemoveConversationChangeEventL(

                mConvChangeHandler,mClientConv));

        }

        delete mClientConv;

        mClientConv = NULL;

    }

    if(mServer && mConvListChangeHandler)

    {

        TRAP_IGNORE(mServer->RemoveConversationListChangeEventL(

                mConvListChangeHandler));

        TRAP_IGNORE(mServer->RemoveResultsEventL ( this ));

        mServer->Cancel();

        delete mServer;

        mServer = NULL;

    }

    delete mConvChangeHandler;

    delete mConvListChangeHandler;

}

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

// ConversationsEnginePrivate::initL

// @see header

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

void ConversationsEnginePrivate::initL()

{

    mServer = CCSRequestHandler::NewL();

    //Add results observer to the server

    mServer->RequestResultsEventL(this);

    //Fetch the conversation list from server

    mServer->GetConversationListL();    

    mConvChangeHandler = new ConversationsChangeHandler(this,

        mConversationsModel);

    mConvListChangeHandler = new ConversationsListChangeHandler(this,

        mConversationsSummaryModel);

}

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

// ConversationsEnginePrivate::registerForConversationListUpdatesL

// @see header

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

void ConversationsEnginePrivate::registerForConversationListUpdatesL()

{

    //Add ConversationListChange Observer

    mServer->RequestConversationListChangeEventL (mConvListChangeHandler);

}

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

// ConversationsEnginePrivate::getConversationsL

// @see header

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

void ConversationsEnginePrivate::getConversationsL( TInt aConversationId)

{	

    if(!mClientConv)

    {

        QCRITICAL_WRITE("ConversationsEnginePrivate::getConversationsL start.");

        //Clear the model before issueing fetch

        mConversationsModel->clear();

        //create a client conversation

        mClientConv = CCsClientConversation::NewL();

        mClientConv->SetConversationEntryId(aConversationId);

        //set dummy entry

        CCsConversationEntry *entry = CCsConversationEntry::NewL();

        CleanupStack::PushL(entry);

        mClientConv->SetConversationEntryL(entry);

        CleanupStack::PopAndDestroy(entry);

        // Reset the values in change handler before initiating a request

        mConvChangeHandler->ResetValuesForNewConversation();

        //Get the conversations for new conversationId 

        mServer->GetConversationsL(mClientConv,0,KMaxConversationIPCLimit);

        QCRITICAL_WRITE("ConversationsEnginePrivate::getConversationsL end.");

        }   

}

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

// ConversationsEnginePrivate::deleteConversationL

// @see header

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

void ConversationsEnginePrivate::deleteConversationL(TInt aConversationId)

{

    mServer->DeleteConversationL(aConversationId);

}

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

// ConversationsEnginePrivate::deleteMessages

// @see header

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

void ConversationsEnginePrivate::deleteMessages(RArray<TInt>& aIdArray)

{

    mConversationMsgStoreHandler->DeleteMessages(aIdArray);

}

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

// ConversationsEnginePrivate::deleteallDraftMessages

// @see header

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

void ConversationsEnginePrivate::deleteAllDraftMessagesL()

{

    mConversationMsgStoreHandler->DeleteAllDraftMessagesL();

}

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

// ConversationsEnginePrivate::markConversationReadL

// @see header

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

void ConversationsEnginePrivate::markConversationReadL(TInt aConversationId)

{

    mServer->MarkConversationReadL(aConversationId);

}

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

// ConversationsEnginePrivate::markMessagesReadL

// @see header

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

void ConversationsEnginePrivate::markMessagesReadL(RArray<TInt>& aIdArray)

{

    mConversationMsgStoreHandler->MarkMessagesReadL(aIdArray);

}

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

// ConversationsEnginePrivate::getConversationCurrentId

// @see header

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

TInt ConversationsEnginePrivate::getConversationCurrentId()

{

    TInt convId = -1;

    if(mClientConv)

    {

        convId = mClientConv->GetConversationEntryId();    

    }

    return convId;

}

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

// ConversationsEnginePrivate::getConversationIdFromContactId

// @see header

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

TInt ConversationsEnginePrivate::getConversationIdFromContactIdL(TInt contactId)

{

    TInt convId = -1;

    convId = mServer->GetConversationIdL(contactId);

    return convId;

}

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

// ConversationsEnginePrivate::getConversationIdFromAddress

// @see header

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

TInt ConversationsEnginePrivate::getConversationIdFromAddressL(TDesC& contactAddress)

{

    TInt convId = -1;

    convId = mServer->GetConversationIdFromAddressL(contactAddress);

    return convId;

}

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

// ConversationsEnginePrivate::getConversationFromConversationId

// @see header

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

CCsClientConversation* ConversationsEnginePrivate::getConversationFromConversationIdL(TInt aConversationId)

{

     return mServer->GetConversationFromConversationIdL(aConversationId);

}

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

// ConversationsEnginePrivate::clearConversationsL

// @see header

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

void ConversationsEnginePrivate::clearConversationsL()

{    

    QCRITICAL_WRITE("ConversationsEnginePrivate::clearConversationsL start.");

    mConvChangeHandler->Cancel();

    //Clear conversations model before populating with new data 

    mConversationsModel->clearModel();

    // Delete old CCsClientConversation object 

    // Remove the old Conversation change observer

    if(mClientConv)

    {   

        int error = KErrNone;

        TRAP(error, mServer->RemoveConversationChangeEventL (mConvChangeHandler ,mClientConv));

        delete mClientConv;

        mClientConv = NULL;

        User::LeaveIfError(error);

    }

    QCRITICAL_WRITE("ConversationsEnginePrivate::clearConversationsL end.");

}

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

// ConversationsEnginePrivate::registerForConversationUpdatesL

// @see header

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

void ConversationsEnginePrivate::registerForConversationUpdatesL()

{

    //Add the Conversation Change for new  conversationId

    if(mClientConv)

    {    

    mServer->RequestConversationChangeEventL (mConvChangeHandler ,mClientConv);

    }

}

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

// ConversationsEnginePrivate::deRegisterCVUpdatesTemporary

// @see header

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

void ConversationsEnginePrivate::deRegisterCVUpdatesTemporary()

{

    mServer->RemoveConversationChangeEventL (mConvChangeHandler ,mClientConv);

}

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

// ConversationsEnginePrivate::registerAgainForConversationUpdatesL

// @see header

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

void ConversationsEnginePrivate::registerAgainForConversationUpdatesL(

        int newConversationId)

{

    //Add the Conversation Change for new  conversationId

    if(mClientConv)

    {    

    mClientConv->SetConversationEntryId(newConversationId);

    mServer->RequestConversationChangeEventL (mConvChangeHandler ,mClientConv);

    }

}

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

// ConversationsEnginePrivate::ConversationList

// @see header

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

void ConversationsEnginePrivate::ConversationList(

    RPointerArray<CCsClientConversation>& aClientConversationList)

{

    int error;

    TRAP(error,

        mConvListChangeHandler->ConversationListL(aClientConversationList));

}

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

// ConversationsEnginePrivate::Conversations

// @see header

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

void ConversationsEnginePrivate::Conversations(

    RPointerArray<CCsConversationEntry>& aConversationEntryList,

    TInt& aTotalCount)

{

    int error;

    if (mClientConv)

        {

        QCRITICAL_WRITE("ConversationsEnginePrivate::Conversations start.");

        TRAP(error,mConvChangeHandler->ConversationsL(aConversationEntryList,aTotalCount));

        QCRITICAL_WRITE("ConversationsEnginePrivate::Conversations end.");

        }

}

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

// ConversationsEngine::fetchMoreConversations

// @see header

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

void ConversationsEnginePrivate::fetchMoreConversations()

{

    if (mClientConv)

        {

        mConvChangeHandler->restartHandleConversations();

        }

}

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

// ConversationsEngine::fetchRemainingConversations

// @see header

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

void ConversationsEnginePrivate::fetchRemainingConversations(TInt& aCount)

    {

    if ( mServer && mClientConv )

            {

            // Get conversations from server

             mServer->GetConversationsL(mClientConv, 

                     (aCount - 1),

                    KMaxConversationIPCLimit);

            }

    }

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

// ConversationsEnginePrivate::resendMessage()

// @see header

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

bool ConversationsEnginePrivate::resendMessage(TMsvId messageId)

{

    TInt err = KErrNone;

    bool retval = true;

    TRAP(err, retval = mConversationMsgStoreHandler->ResendMessageL(messageId));

    return ((err == KErrNone) && (retval == true))?true:false;

}

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

// ConversationsEnginePrivate::downloadMessage

// @see header

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

TInt ConversationsEnginePrivate::downloadMessage(TMsvId messageId)

{

    TInt err = KErrNone;

    TInt retval = KErrNone;

    TRAP(err, retval = 

            mConversationMsgStoreHandler->DownloadMessageL(messageId));

    if( err!=KErrNone)

    {

        retval = KErrGeneral;

    }

    return retval;

}

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

// ConversationsEnginePrivate::downloadOperationSupported()

// @see header

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

bool ConversationsEnginePrivate::downloadOperationSupported(TMsvId messageId)

{

  return mConversationMsgStoreHandler->DownloadOperationSupported(messageId);   

}

//EOF