/*

* Copyright (c) 2005 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:  Handler class for incoming and outgoing messages

*

*/

#include "CCAMessageHandler.h"

#include "MCAChatInterface.h"

#include "MCAMessagesWriteInterface.h"

#include "MCAMessageUtils.h"

#include "MCAImpsImClient.h"

#include "MCASettings.h"

#include "MCAMessageErrorObserver.h"

#include "MCAImpsFactory.h"

#include "PublicEngineDefinitions.h"

#include "impsbuilddefinitions.h"

#include "mcabuffermemoryhandler.h"

#include "camessageutil.h"

#include <apmstd.h> // KMaxDataTypeLength

#include <utf.h>    // CnvUtfConverter

#include "ChatDebugPrint.h"

#include "ImpsCSPAllErrors.h"

// "test character identity and accents, ignore case"

const TInt KCollationLevel = 1;

const TInt KMemorySafeValue = 1024; // One kbyte for safe memory allocation.

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

// CCAMessageHandler::CCAMessageHandler

// ( Other items commented in header )

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

CCAMessageHandler::CCAMessageHandler( MCAChatInterface& aChatInterface,

                                      MCAMessageUtils& aMessageUtils,

                                      MCAImpsFactory* aIMPSFactory )

        : iMessageUtils( aMessageUtils ),

        iChatInterface( aChatInterface ),

        iImpsFactory( aIMPSFactory )

    {

    }

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

// CCAMessageHandler::~CCAMessageHandler

// ( Other items commented in header )

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

CCAMessageHandler::~CCAMessageHandler()

    {

    CHAT_DP_FUNC_ENTER( "CCAMessageHandler::~CCAMessageHandler" );

    delete iIdle;

    if ( iSendBuffer )

        {

        iSendBuffer->SetObserver( NULL );

        }

    iErrorObservers.Close();

    iHoldingMessages.Close();

    CHAT_DP_FUNC_DONE( "CCAMessageHandler::~CCAMessageHandler" );

    }

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

// CCAMessageHandler::NewL

// ( Other items commented in header )

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

CCAMessageHandler* CCAMessageHandler::NewL(

    MCAChatInterface& aChatInterface,

    MCAMessageUtils& aMessageUtils,

    MCAImpsFactory* aIMPSFactory )

    {

    CHAT_DP_FUNC_ENTER( "CCAMessageHandler::NewL" );

    CCAMessageHandler* self = CCAMessageHandler::NewLC(

                                  aChatInterface,

                                  aMessageUtils,

                                  aIMPSFactory );

    CleanupStack::Pop( self );

    CHAT_DP_FUNC_DONE( "CCAMessageHandler::NewL" );

    return self;

    }

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

// CCAMessageHandler::NewLC

// ( Other items commented in header )

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

CCAMessageHandler* CCAMessageHandler::NewLC(

    MCAChatInterface& aChatInterface,

    MCAMessageUtils& aMessageUtils,

    MCAImpsFactory* aIMPSFactory )

    {

    CHAT_DP_FUNC_ENTER( "CCAMessageHandler::NewLC" );

    CCAMessageHandler* self = new ( ELeave ) CCAMessageHandler(

        aChatInterface,

        aMessageUtils,

        aIMPSFactory );

    CleanupStack::PushL( self );

    self->ConstructL();

    CHAT_DP_FUNC_DONE( "CCAMessageHandler::NewLC" );

    return self;

    }

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

// CCAMessageHandler::ConstructL

// ( Other items commented in header )

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

void CCAMessageHandler::ConstructL()

    {

    CHAT_DP_FUNC_ENTER( "CCAMessageHandler::ConstructL" );

    iImpsImClient = iImpsFactory->CreateImClientL();

    iSendBuffer = &iChatInterface.MessageReadInterfaceL( KNullDesC, KNullDesC );

    iSendBuffer->SetObserver( this );

    iIdle = CIdle::NewL( CActive::EPriorityIdle );

    CHAT_DP_FUNC_DONE( "CCAMessageHandler::ConstructL" );

    }

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

// CCAMessageHandler::HandleNewTextMessageL

// ( Other items commented in header )

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

void CCAMessageHandler::HandleNewTextMessageL(  TInt aOpId,

                                                const TDesC& /*aMessageId*/,

                                                const TDesC& aSender,

                                                const TDesC& aGroupId,

                                                const MDesCArray& aRecipients,

                                                const MDesCArray& aScreenNames,

                                                const TDesC& aText,

                                                TImpsCspIdentifier& aCspId )

    {

    CHAT_DP_FUNC_ENTER( "CCAMessageHandler::HandleNewTextMessageL" );

    // Don't use memory handling if this is local echo message

    MCAMessagesWriteInterface& messageContainer =

        iChatInterface.MessageWriteInterfaceL(

            aCspId.Sap(),

            aCspId.UserId(),

            ( aGroupId == KNullDesC ? aSender : aGroupId ) );

    if ( !( aGroupId != KNullDesC &&

            iLocalEchoInGroup &&

            messageContainer.OwnScreenName().CompareC( aSender, KCollationLevel, NULL ) == 0 ) )

        {

        if ( !iMessageUtils.MemoryHandler().FreeMemoryIfNeededL( KMemorySafeValue + aText.Size() ) )

            {

            NotifyMessageError( KErrNoMemory, NULL );

            User::Leave( KErrNoMemory );

            }

        }

    HBufC* sap = aCspId.Sap().AllocLC();

    HBufC* userId = aCspId.UserId().AllocLC();

    MCAMessageCreator::SMessageData data =

        {

        KMessageDataVersion,

        aOpId,

        *sap,

        *userId,

        aSender,

        ( aGroupId == KNullDesC ? aSender : aGroupId ),

        &aRecipients,

        &aScreenNames,

        aText,

        KNullDesC8,

        KNullDesC8,

        MCAMessage::EMessageReceived

        };

    HandleNewMessageL( data );

    CleanupStack::PopAndDestroy( 2, sap );

    CHAT_DP_FUNC_DONE( "CCAMessageHandler::HandleNewTextMessageL" );

    }

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

// CCAMessageHandler::HandleNewContentMessageL

// ( Other items commented in header )

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

void CCAMessageHandler::HandleNewContentMessageL(

    TInt aOpId,

    const TDesC& /*aMessageId*/,

    const TDesC& aSender,

    const TDesC& aGroupId,

    const MDesCArray& aRecipients,

    const MDesCArray& aScreenNames,

    const TDesC& aContentType,

    const TDesC8& aContent,

    TImpsCspIdentifier& aCspId )

    {

    CHAT_DP_FUNC_ENTER( "CCAMessageHandler::HandleNewContentMessageL" );

    // Don't use memory handling if this is local echo message

    MCAMessagesWriteInterface& messageContainer =

        iChatInterface.MessageWriteInterfaceL(

            aCspId.Sap(),

            aCspId.UserId(),

            ( aGroupId == KNullDesC ? aSender : aGroupId ) );

    if ( !( aGroupId != KNullDesC &&

            iLocalEchoInGroup &&

            messageContainer.OwnScreenName().CompareC( aSender, KCollationLevel, NULL ) == 0 ) )

        {

        if ( !iMessageUtils.MemoryHandler().FreeMemoryIfNeededL( KMemorySafeValue + aContent.Size() ) )

            {

            NotifyMessageError( KErrNoMemory, NULL );

            User::Leave( KErrNoMemory );

            }

        }

    HBufC* sap = aCspId.Sap().AllocLC();

    HBufC* userId = aCspId.UserId().AllocLC();

    TBuf8< KMaxDataTypeLength > mimeType;

    CnvUtfConverter::ConvertFromUnicodeToUtf8( mimeType, aContentType );

    MCAMessageCreator::SMessageData data =

        {

        KMessageDataVersion,

        aOpId,

        *sap,

        *userId,

        aSender,

        ( aGroupId == KNullDesC ? aSender : aGroupId ),

        &aRecipients,

        &aScreenNames,

        KNullDesC,

        mimeType,

        aContent,

        MCAMessage::EMessageReceived

        };

    HandleNewMessageL( data );

    CleanupStack::PopAndDestroy( 2, sap );

    CHAT_DP_FUNC_DONE( "CCAMessageHandler::HandleNewContentMessageL" );

    }

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

// CCAMessageHandler::HandleNewMessageL

// ( Other items commented in header )

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

void CCAMessageHandler::HandleNewMessageL(

    MCAMessageCreator::SMessageData& aData )

    {

    CHAT_DP_FUNC_ENTER( "CCAMessageHandler::HandleNewMessageL" );

    if ( aData.iTargetId == KNullDesC )

        {

        // Invalid message.

        User::Leave( KErrArgument );

        }

    MCAMessagesWriteInterface& messageContainer =

        iChatInterface.MessageWriteInterfaceL( aData.iSapId,

                                               aData.iUserId,

                                               aData.iTargetId );

    MCAMessage* message = iMessageUtils.MessageCreator().CreateMessageL( aData );

    if ( iLocalEchoInGroup

         && ( message->MessageType() == MCAMessage::EMessageGroup )

         && ( messageContainer.OwnScreenName().CompareC( aData.iSender,

                                                         KCollationLevel, NULL ) == 0 ) )

        {

        // Do not show message because it is already shown with local echo.

        CHAT_DP( D_CHAT_LIT( "Group message not shown, because local echo." ) );

        delete message;

        return;

        }

    // set iTargetId to ScreenName if current received message type is EMessageWhisper

    if ( message->MessageType() == MCAMessage::EMessageWhisper || message->MessageType() == MCAMessage::EMessageGroup )

        {

        TInt count = aData.iScreenNames->MdcaCount();

        MCAMessageCreator::SMessageData data2 =

            {

            aData.iVersion,

            aData.iOpId,

            aData.iSapId,

            aData.iUserId,

            aData.iSender,

            ( count > 0 ) ? aData.iScreenNames->MdcaPoint( 0 ) : aData.iTargetId,

            aData.iRecipients,

            aData.iScreenNames,

            aData.iText,

            aData.iContentType,

            aData.iContentData,

            aData.iMessager

            };

        MCAMessage* message2 = iMessageUtils.MessageCreator().CreateMessageL( data2 );

        delete message;

        message = message2;

        }

    // Message can get different process state during creation. For example

    // EContentNotSupported

    if ( message->ContentProcessState() == MCAMessage::EContentNotProcessed )

        {

        message->SetProcessState( MCAMessage::EContentReady );

        }

    // Add message

    CAMessageUtil::AppendMessageWithDateStampL(

        *message,

        messageContainer,

        iMessageUtils.MessageCreator() );

    CHAT_DP_FUNC_DONE( "CCAMessageHandler::HandleNewMessageL" );

    }

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

// CCAMessageHandler::HandleSendCompleteL

// ( Other items commented in header )

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

void CCAMessageHandler::HandleSendCompleteL(	TInt aOpId,

                                             TBool aDeliveryReportOrdered,

                                             TImpsCspIdentifier& /*aCspId*/ )

    {

    CHAT_DP_FUNC_ENTER( "CCAMessageHandler::HandleSendCompleteL" );

    CHAT_DP( D_CHAT_LIT( "Operationcode %d. Delivery ordered %d" ),

             aOpId, aDeliveryReportOrdered );

    HandleMessageSentL( KErrNone, aOpId, ETrue );

    CHAT_DP_FUNC_DONE( "CCAMessageHandler::HandleSendCompleteL" );

    }

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

// CCAMessageHandler::HandleDeliveryReportL

// ( Other items commented in header )

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

void CCAMessageHandler::HandleDeliveryReportL(	const TDesC& /*aMessageId*/,

                                               TInt /*aResult*/,

                                               const TDesC* /*aDescription*/,

                                               TImpsCspIdentifier& /*aCspId*/ )

    {

    CHAT_DP_FUNC_ENTER( "CCAMessageHandler::HandleDeliveryReportL" );

    CHAT_DP_FUNC_DONE( "CCAMessageHandler::HandleDeliveryReportL" );

    }

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

// CCAMessageHandler::HandleMessageEvent

// ( Other items commented in header )

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

void CCAMessageHandler::HandleMessageEvent( TMessageEventType aEvent,

                                            TInt /*aIndex*/ )

    {

    CHAT_DP_FUNC_ENTER( "CCAMessageHandler::HandleMessageEvent" );

    switch ( aEvent )

        {

        case ENewMessage:

            {

            if ( !iIdle->IsActive() )

                {

                iIdle->Start( TCallBack( SendMessage, this ) );

                }

            break;

            }

        case EChatDeleted:

            {

            // send buffer was deleted

            iSendBuffer = NULL;

            break;

            }

        default:

            break;

        }

    CHAT_DP_FUNC_DONE( "CCAMessageHandler::HandleMessageEvent" );

    }

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

// CCAMessageHandler::SendMessage

// ( Other items commented in header )

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

TInt CCAMessageHandler::SendMessage( TAny *aInstance )

    {

    CCAMessageHandler* handler = static_cast< CCAMessageHandler* >( aInstance );

    handler->iSendLaunchLock = ETrue;

    TInt retVal = handler->DoSendMessage();

    handler->iSendLaunchLock = EFalse;

    return retVal;

    }

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

// CCAMessageHandler::DoSendMessage

// ( Other items commented in header )

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

TInt CCAMessageHandler::DoSendMessage()

    {

    CHAT_DP_FUNC_ENTER( "CCAMessageHandler::DoSendMessage" );

    if ( !iSendBuffer )

        {

        // send buffer was deleted, we're shutting down

        CHAT_DP( D_CHAT_LIT( "There is no send buffer." ) );

        return EFalse;

        }

    // 1. Check if there is message in holding.

    MCAMessage* holdingMessage = NextHoldingMessage();

    if ( !holdingMessage && !iSendBuffer->UnreadCount() )

        {

        CHAT_DP( D_CHAT_LIT( "There is not ready messages for sending." ) );

        return EFalse;

        }

    // 2. Choose new message from sendbuffer or use holding message if exists.

    MCAMessage& message = ( !holdingMessage ? iSendBuffer->ReadNextUnread()

                            : *holdingMessage );

    // 3. Add message to holding if needed

    TBool appendedToHolding( EFalse );

    TRAPD( error, appendedToHolding = AppendedToHoldingL( message ) );

#ifndef RD_SEND_NOT_SUPPORTED_CONTENT

    if ( error ) // Corrupted message, inform upstairs

        {

        NotifyMessageError(

            error == KErrOverflow ? error : ECorruptedContent, &message );

        // Remove sent message from send buffer, because answer will not come.

        TInt index = iSendBuffer->FindIndex( message );

        if ( index >= 0 )

            {

            iSendBuffer->DeleteMessage( index );

            }

        return ETrue;

        }

#endif //RD_SEND_NOT_SUPPORTED

    if ( appendedToHolding )

        {

        return ETrue;

        }

    // 4. Send message

    TInt opCode( 0 );

    TRAP( error, opCode = SendMessageToServerL( message ) );

    CHAT_DP( D_CHAT_LIT( "Send retval ( %d )" ), error );

    if ( error == KErrServerBusy )

        {

        TRAPD( err, iHoldingMessages.AppendL( &message ) );

        if ( err )

            {

            CActiveScheduler::Current()->Error( err );

            }

        return ETrue;

        }

    // 5. Local echo message

    TRAPD( error2, LocalEchoMessageL( message ) );

    if ( error2 != KErrNone )

        {

        NotifyMessageError( error2, &message );

        }

    // 6. Handle error

    if ( error != KErrNone )

        {

        TRAP( error2, HandleMessageSentFailedL( message, error ) );

        if ( error2 )

            {

            NotifyMessageError( error2, &message );

            }

        // Remove sent message from send buffer, because answer will not come.

        TInt index = iSendBuffer->FindIndex( message );

        if ( index >= 0 )

            {

            iSendBuffer->DeleteMessage( index );

            }

        }

    else // Send succesfull. -> Local echo

        {

        CHAT_DP( D_CHAT_LIT( "Address: %s, UserId: %s, Recipient %s" ),

                 &message.ServerAddress(),

                 &message.UserId(),

                 &message.Recipient() );

        message.SetOperationCode( opCode );

        }

    // 7. Check need of

    TInt unreadCount = iSendBuffer->UnreadCount();

    TInt holdingMessages( iHoldingMessages.Count() );

    CHAT_DP( D_CHAT_LIT( "Still %d messages to go. Send buffer has %d messages. \

                          Holding %d messages" ),

             unreadCount, iSendBuffer->MessageCount(), holdingMessages );

    CHAT_DP_FUNC_DONE( "CCAMessageHandler::DoSendMessage" );

    return Max( unreadCount, holdingMessages );

    }

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

// CCAMessageHandler::HandleMessageSentL

// ( Other items commented in header )

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

void CCAMessageHandler::HandleMessageSentL( TInt aStatus, TInt aOperationCode,

                                            TBool aSuccess )

    {

    CHAT_DP_FUNC_ENTER( "CCAMessageHandler::HandleMessageSentL" );

    CHAT_DP( D_CHAT_LIT( "OpCode = %d, Success = %d" ), aOperationCode, aSuccess );

    if ( !iSendBuffer )

        {

        // send buffer was deleted, we're shutting down

        CHAT_DP( D_CHAT_LIT( "There is no send buffer." ) );

        return;

        }

    TInt index = User::LeaveIfError( iSendBuffer->FindIndex( aOperationCode ) );

    if ( !aSuccess )

        {

        MCAMessage& message = iSendBuffer->Message( index );

        message.SetContainerInfo( NULL );

        MCAMessage* failedMessage =

            iMessageUtils.MessageCreator().CreateFailedMessageL( &message );

        CleanupDeletePushL( failedMessage );

        MCAMessagesWriteInterface& messageContainer =

            iChatInterface.MessageWriteInterfaceL( message.ServerAddress(),

                                                   message.UserId(),

                                                   message.Recipient() );