/*

 * 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:  CS Session class

 *

 */

// INCLUDE FILES

#include <ccsconversationentry.h>

#include <ccsclientconversation.h>

#include "ccsconversationevent.h"

#include "ccsdebug.h"

#include "ccsserver.h"

#include "ccssession.h"

#include "ccsplugininterface.h"

#include "ccsconversationcache.h"

#include "ccscontactsresolver.h"

#include "ccsconversationdeletehandler.h"

#include "ccsconversationmarkreadhandler.h"

// CONSTANTS

const TInt KTinyBuffer = 256; // 256 bytes

const TInt KBigBuffer = 2048; // 2K

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

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

// CCsSession::NewL

// Two Phase Construction

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

CCsSession* CCsSession::NewL(CCsServer* aServer)

{

    PRINT ( _L("Enter CCsSession::NewL") );

    CCsSession* self = new (ELeave) CCsSession(aServer);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self); // self

    PRINT ( _L("End CCsSession::NewL") );

    return self;

}

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

// CCsSession::CCsSession

// Construtor

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

CCsSession::CCsSession(CCsServer* aServer) :

    iServer(aServer)

{

}

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

// CCsSession::ConstructL

// Second phase constructor

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

void CCsSession::ConstructL()

{

    PRINT ( _L("Enter CCsSession::ConstructL") );

    iBufferOverflow = EFalse;

    iGetConversationBufferOverflow = EFalse;

    des = NULL;

    iNotifyHandling = EFalse;

    iConversationListChangeObserver = EFalse;

    iConversationChangeObserver = EFalse;

    iCachingChangeObserver = EFalse;

    iMonitoredConversation = NULL;

    // initialize the event List

    iEventList = new (ELeave) RPointerArray<CCsConversationEvent> ();

    iReqCnt = 1; //Let's start the event ID from 1

    PRINT ( _L("End CCsSession::ConstructL") );

}

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

// CCsSession::CCsSession

// Destructor

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

CCsSession::~CCsSession()

{

    PRINT ( _L("Enter CCsSession::~CCsSession") );

    if (des)

    {

        delete des;

        des = NULL;

    }

    if (iEventList)

    {

        iEventList->ResetAndDestroy();

        iEventList->Close();

        delete iEventList;

        iEventList = NULL;

    }

    if (iMonitoredConversation)

    {

        delete iMonitoredConversation;

        iMonitoredConversation = NULL;

    }

    PRINT ( _L("End CCsSession::~CCsSession") );

}

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

// CCsSession::ServiceL

//

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

void CCsSession::ServiceL(const RMessage2& aMessage)

{

    TInt errStatus = KErrNone;

    // Do the service

    TRAP ( errStatus, DoServiceL(aMessage) );

    // Check the error status returned

    if (errStatus != KErrNone)

    {

        aMessage.Complete(errStatus);

    }

}

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

// CCsSession::DoServiceL

//

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

void CCsSession::DoServiceL(const RMessage2& aMessage)

{

    switch (aMessage.Function())

    {

        case EGetConversationList:

            PRINT ( _L("Received function EGetConversationList") )

            GetConversationListL(aMessage);

            break;

        case EGetConversationUnreadList:

            PRINT ( _L("Received function EGetConversationUnreadList") )

            GetConversationUnreadListL(aMessage);

            break;

        case EGetConversations:

            PRINT ( _L("Received function EGetConversations") )

            GetConversationsL(aMessage);

            break;

        case EGetTotalUnreadCount:

            PRINT ( _L("Received function EGetTotalUnreadCount") )

            GetTotalUnreadCountL(aMessage);

            break;

        case ERequestChangeEvent:

            PRINT ( _L("Received function ERequestChangeEvent") )

            RequestChangeEventL(aMessage);

            break;

        case ERemoveChangeEvent:

            PRINT ( _L("Received function ERemoveChangeEvent") )

            RemoveChangeEventL(aMessage);

            break;

        case ESetConversationListChangeObserver:

            PRINT ( _L("Received function ESetConversationListChangeObserver") )

            SetConversationListChangeObserverL(aMessage);

            break;

        case EResetConversationListChangeObserver:

            PRINT ( _L("Received function EResetConversationListChangeObserver") )

            ResetConversationListChangeObserverL(aMessage);

            break;

        case ESetConversationChangeObserver:

            PRINT ( _L("Received function ESetConversationChangeObserver") )

            SetConversationChangeObserverL(aMessage);

            break;

        case EResetConversationChangeObserver:

            PRINT ( _L("Received function EResetConversationChangeObserver") )

            ResetConversationChangeObserverL(aMessage);

            break;

        case ESetCachingStatusObserver:

            PRINT ( _L("Received function ESetCachingStatusObserver") )

            SetCachingStatusObserverL(aMessage);

            break;

        case EResetCachingStatusObserver:

            PRINT ( _L("Received function EResetCachingStatusObserver") )

            ResetCachingStatusObserverL(aMessage);

            break;

        case EGetCachingStatus:

            GetCachingStatusL(aMessage);

            break;

        case EShutdown:

            PRINT ( _L("Received function EShutdown") )

            ShutdownServerL(aMessage);

            break;

        case EUserDeleteConversation:

            PRINT ( _L("Received function EDeleteConversation") )

            DeleteConversationL(aMessage);

            break;

        case EGetConversationId:

            PRINT ( _L("Received function EGetConversationId") )

            GetConversationIdL(aMessage);

            break;

        case EGetConversationIdFromAddress:

            PRINT ( _L("Received function EGetConversationIdFromAddress") )

            GetConversationIdfromAddressL(aMessage);

            break;

		case EGetConversationFromMessageId:

            PRINT ( _L("Received function EGetConversationFromMessageId") )

            GetConversationFromMessageIdL(aMessage);

            break;

        case EUserMarkReadConversation:

            PRINT ( _L("Received function EUserMarkReadConversation") )

            MarkConversationReadL(aMessage);

            break;

    }

    return;

}

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

// CCsSession::ServiceError

//

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

void CCsSession::ServiceError(const RMessage2& aMessage, TInt aError)

{

    aMessage.Complete(aError);

}

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

// CCsSession::GetConversationEntryListL

// the function to handle the request of Listing

// of recent(latest) conversation entry and

// list of dispalyname for all stored conversation entry ID

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

void CCsSession::GetConversationListL(const RMessage2& aMessage)

{

    PRINT ( _L("Enter CCsSession::GetConversationListL") );

    PRINT_TIMESTAMP ("Enter CCsSession::GetConversationListL");

    if (iBufferOverflow == EFalse)

    {

        RPointerArray<CCsClientConversation>* ClientConversationList =

                new (ELeave) RPointerArray<CCsClientConversation> ();

        // get cache pointer

        CCsConversationCache* cache = iServer->ConversationCacheInterface();

        // Call cache function to get recent conversation entry list

        // with dispaly name for all stored conversation entry ID

        cache->GetConversationListL(ClientConversationList);

        CleanupStack::PushL(ClientConversationList);

        //write all list data into stream

        // create a new buffer for writing into stream

        CBufFlat* buf = CBufFlat::NewL(KBigBuffer);

        CleanupStack::PushL(buf);

        RBufWriteStream writeStream(*buf);

        writeStream.PushL();

        TInt listCount = ClientConversationList->Count();

        if (listCount == 0)

        {

            iConversationListChangeObserver = ETrue;

        }

        // write the count first

        writeStream.WriteUint16L(listCount);

        // now go through the list and do externalize

        for (int iloop = 0; iloop < listCount; iloop++)

        {

            CCsClientConversation

                    * ClientConversation =

                            static_cast<CCsClientConversation*> ( (*ClientConversationList)[iloop]);

            //write list of ClientConversation

            ClientConversation->ExternalizeL(writeStream);

        }

        // Results are already packed in the stream

        writeStream.CommitL();

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

        // Create a heap descriptor from the buffer

        des = HBufC8::NewLC(buf->Size());

        CleanupStack::Pop(des);

        TPtr8 ptr(des->Des());

        buf->Read(0, ptr, buf->Size());

        // cleanup

        CleanupStack::PopAndDestroy(2, buf); // writestream, buf

        CleanupStack::Pop(ClientConversationList);

        // destroy objects inside list

        ClientConversationList->ResetAndDestroy();

        ClientConversationList->Close();

        delete ClientConversationList;

        ClientConversationList = NULL;

    }

    TInt rcevdBufferSize = aMessage.GetDesMaxLength(1);

    TInt reqdBufferSize = des->Size();

    PRINT1 ( _L("Received buffer size = %d"), rcevdBufferSize );

    PRINT1 ( _L("Required buffer size = %d"), reqdBufferSize );

    // If the received buffer size from Client API is less than

    // the required buffer size write the required buffer size

    // and return.

    if (rcevdBufferSize < reqdBufferSize)

    {

        PRINT ( _L("In-adequate buffer received") );

        PRINT ( _L("Packing the required buffer size in response") );

        TPckgC<TInt> bufferSizePackage(reqdBufferSize);

        aMessage.WriteL(1, bufferSizePackage);

        aMessage.Complete(EGetConversationListBufferOverflow);

        iBufferOverflow = ETrue;

    }

    else

    {

        PRINT ( _L("Adequate buffer received") );

        PRINT ( _L("Packing the results in response") )

        aMessage.Write(1, *des);

        aMessage.Complete(EGetConversationListOperationComplete);

        iBufferOverflow = EFalse;

        delete des;

        des = NULL;

    }

    PRINT_TIMESTAMP ("End CCsSession::GetConversationListL");

    PRINT ( _L("End CCsSession::GetConversationListL") );

}

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

// CCsSession::GetConversationUnreadListL

// the function to handle the request of Listing

// of recent(latest) unread conversation entry and

// list of dispalyname for all stored conversation entry ID

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

void CCsSession::GetConversationUnreadListL(const RMessage2& aMessage)

    {

    PRINT ( _L("Enter CCsSession::GetConversationUnreadListL") );

    PRINT_TIMESTAMP ("Enter CCsSession::GetConversationUnreadListL");

    if (iBufferOverflow == EFalse)

        {

        RPointerArray<CCsClientConversation>* ClientConversationList =

                new (ELeave) RPointerArray<CCsClientConversation> ();

        // get cache pointer

        CCsConversationCache* cache = iServer->ConversationCacheInterface();

        // Call cache function to get recent conversation entry list

        // with dispaly name for all stored conversation entry ID

        cache->GetConversationUnreadListL(ClientConversationList);

        CleanupStack::PushL(ClientConversationList);

        //write all list data into stream

        // create a new buffer for writing into stream

        CBufFlat* buf = CBufFlat::NewL(KBigBuffer);

        CleanupStack::PushL(buf);

        RBufWriteStream writeStream(*buf);

        writeStream.PushL();

        TInt listCount  = ClientConversationList->Count();

        if (listCount == 0)

            {

            iConversationListChangeObserver = ETrue;

            }

        // write the count first

        writeStream.WriteUint16L(listCount);

        // now go through the list and do externalize

        for (int iloop=0 ; iloop < listCount ; iloop++)

            {

            CCsClientConversation* ClientConversation =

            static_cast<CCsClientConversation*>((*ClientConversationList)[iloop]);

            //write list of ClientConversation

            ClientConversation->ExternalizeL(writeStream);

            }

        // Results are already packed in the stream

        writeStream.CommitL();

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

        // Create a heap descriptor from the buffer

        des = HBufC8::NewLC(buf->Size());

        CleanupStack::Pop(des);

        TPtr8 ptr(des->Des());

        buf->Read(0, ptr, buf->Size());

        // cleanup

        CleanupStack::PopAndDestroy(2, buf); // writestream, buf

        CleanupStack::Pop(ClientConversationList);

        // destroy objects inside list

        ClientConversationList->ResetAndDestroy();

        ClientConversationList->Close();

        delete ClientConversationList;

        ClientConversationList = NULL;

        }

    TInt rcevdBufferSize = aMessage.GetDesMaxLength(1);

    TInt reqdBufferSize  = des->Size();

    PRINT1 ( _L("Received buffer size = %d"), rcevdBufferSize );

    PRINT1 ( _L("Required buffer size = %d"), reqdBufferSize );

    if ( rcevdBufferSize < reqdBufferSize )

        {

        PRINT ( _L("In-adequate buffer received") );

        PRINT ( _L("Packing the required buffer size in response") );

        TPckgC<TInt> overflowPackage(ETrue);

        aMessage.WriteL(0, overflowPackage);

        TPckgC<TInt> bufferSizePackage(reqdBufferSize);

        aMessage.WriteL(1, bufferSizePackage);

        aMessage.Complete(KErrNone);

        iBufferOverflow = ETrue;

        }

    else

        {

        PRINT ( _L("Adequate buffer received") );

        PRINT ( _L("Packing the results in response") )

        TPckgC<TInt> overflowPackage(EFalse);

        aMessage.WriteL(0, overflowPackage);

        aMessage.Write(1, *des);

        aMessage.Complete(KErrNone);

        iBufferOverflow = EFalse;

        delete des;

        des = NULL;

        }

    PRINT_TIMESTAMP ("End CCsSession::GetConversationUnreadListL");

    PRINT ( _L("End CCsSession::GetConversationUnreadListL") );

    }

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

// CCsSession::GetConversationsL

// the function to handle the request

// of conversation entry list for one conversation entry ID

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

void CCsSession::GetConversationsL(const RMessage2& aMessage)

{

    PRINT ( _L("Enter CCsSession::GetConversationsL") );

    if (iGetConversationBufferOverflow == EFalse)

    {

        // Read Contact from the message

        HBufC8* buffer = HBufC8::NewLC(KBigBuffer);

        TPtr8 bufferPtr(buffer->Des());

        aMessage.ReadL(0, bufferPtr);

        // Stream over the buffer

        RDesReadStream stream(bufferPtr);

        stream.PushL();

        // get cache pointer

        CCsConversationCache* cache = iServer->ConversationCacheInterface();

        // read the Client Conversation consist of Entry Id

        CCsClientConversation* ClientConversation =

                CCsClientConversation::NewL();

        CleanupStack::PushL(ClientConversation);

        ClientConversation->InternalizeL(stream);

        CleanupStack::Pop(ClientConversation);

        CleanupStack::PopAndDestroy(2, buffer);//stream, buffer

        CleanupStack::PushL(ClientConversation);

        RPointerArray<CCsConversationEntry>* conversationEntryList =

                new (ELeave) RPointerArray<CCsConversationEntry> ();

        CleanupStack::PushL(conversationEntryList);

        // get conversationlist for given ClientConversation 

        cache->GetConversationsL(ClientConversation, conversationEntryList);

        // create a new buffer for writing into stream

        // write all list data into stream

        CBufFlat* buf = CBufFlat::NewL(KBigBuffer);

        CleanupStack::PushL(buf);

        RBufWriteStream writeStream(*buf);

        writeStream.PushL();

        TInt ItemCount = conversationEntryList->Count();

        //write  recent conversation entry list

        writeStream.WriteInt32L(ItemCount);

        // Write the conversation entry

        for (TInt iloop = 0; iloop < ItemCount; iloop++)

        {

            CCsConversationEntry

                    * entry =