/*

* Copyright (c) 2006-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: This file implements class CIpsPlgCreateReplyMessageOperation.

*

*/

// <qmail>

// INCLUDE FILES

#include "emailtrace.h"

#include "ipsplgheaders.h"

// LOCAL CONSTANTS AND MACROS

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

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

// CIpsPlgCreateReplyMessageOperation::CIpsPlgCreateReplyMessageOperation

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

//

CIpsPlgCreateReplyMessageOperation::CIpsPlgCreateReplyMessageOperation(

    CIpsPlgSmtpService* aSmtpService,

    CMsvSession& aMsvSession,

    TRequestStatus& aObserverRequestStatus,

    TMsvPartList aPartList,

    TMsvId aMailBoxId,

    TMsvId aOriginalMessageId, 

    MFSMailRequestObserver& aOperationObserver,

    const TInt aRequestId ) 

    :

    CIpsPlgCreateMessageOperation(

        aSmtpService,

        aMsvSession,

        aObserverRequestStatus,

        KMsvNullIndexEntryId,

        aPartList,

        aMailBoxId,

        aOperationObserver,

        aRequestId),

    iOriginalMessageId(aOriginalMessageId)

    {

    FUNC_LOG;

    }

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

// CIpsPlgCreateReplyMessageOperation::NewL

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

//

CIpsPlgCreateReplyMessageOperation* CIpsPlgCreateReplyMessageOperation::NewL(

    CIpsPlgSmtpService* aSmtpService,

    CMsvSession& aMsvSession,

    TRequestStatus& aObserverRequestStatus,

    TMsvPartList aPartList,

    TMsvId aMailBoxId,

    TMsvId aOriginalMessageId, 

    MFSMailRequestObserver& aOperationObserver,

    const TInt aRequestId )

    {

    FUNC_LOG;

    CIpsPlgCreateReplyMessageOperation* self =

        new (ELeave) CIpsPlgCreateReplyMessageOperation(

            aSmtpService, 

            aMsvSession, 

            aObserverRequestStatus,

            aPartList, 

            aMailBoxId, 

            aOriginalMessageId, 

            aOperationObserver, 

            aRequestId );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); 

    return self;

    }

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

// CIpsPlgCreateReplyMessageOperation::~CIpsPlgCreateReplyMessageOperation

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

//

CIpsPlgCreateReplyMessageOperation::~CIpsPlgCreateReplyMessageOperation()

    {

    }

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

// CIpsPlgCreateReplyMessageOperation::RunL

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

//

void CIpsPlgCreateReplyMessageOperation::RunL()

    {

    FUNC_LOG;

    if( iStatus.Int() == KErrNone )

        {

        CFSMailMessage* newMessage = NULL;

        // new message creation has finished and we have an id...

        TMsvId msgId = TMsvId();

        TRAPD( err, msgId = GetIdFromProgressL( iOperation->FinalProgress() ) );

        if( err == KErrNone )

            {

            //  ...so we can create an FS type message

            newMessage = iSmtpService->CreateFSMessageAndSetFlagsL( 

                    msgId, iOriginalMessageId, iMailBoxId );

            CleanupStack::PushL( newMessage ); // ***

            // dig out new reply message's header

            CMsvEntry* cEntry = iMsvSession.GetEntryL( msgId );

            CleanupStack::PushL( cEntry ); // ***

            CMsvStore* store = cEntry->ReadStoreL();

            CleanupStack::PushL( store ); // ***

            if( store->IsPresentL( KUidMsgFileIMailHeader ) == EFalse )

                 {

                 User::Leave(KErrCorrupt);

                 }

            CImHeader* header = CImHeader::NewLC(); // ***

            header->RestoreL( *store );

            // Start handling recipients

            HBufC* emailAddr( NULL );

            CFSMailAddress* fsAddr( NULL );

            // copy to recipients            

            TInt toRecipientCount( header->ToRecipients().Count() );

            for( TInt i = 0; i < toRecipientCount; i++ )

                {

                emailAddr = header->ToRecipients()[i].AllocLC(); // ***

                fsAddr = CFSMailAddress::NewLC(); // ***

                fsAddr->SetEmailAddress( *emailAddr ); // Copy created

                newMessage->AppendToRecipient( fsAddr ); // No copy

                CleanupStack::Pop( fsAddr ); // fsAddr belong now to fsMsg

                CleanupStack::PopAndDestroy( emailAddr ); // emailAddr not used

                }

            // get additional recipients (reply all case)

            if( iPartList & KMsvMessagePartRecipient )

                {

                // check if CC recipient read from header was present in To field

                // of original message. If so, copy it into To recipients.

                // 

                CMsvEntry* tmpEntry = iMsvSession.GetEntryL( iOriginalMessageId );

                CleanupStack::PushL( tmpEntry ); // ***

                CMsvStore* tmpStore = tmpEntry->ReadStoreL();

                CleanupStack::PushL( tmpStore ); // ***

                if( tmpStore->IsPresentL( KUidMsgFileIMailHeader ) )

                    {

                    CImHeader* tmpHeader = CImHeader::NewLC(); // ***

                    tmpHeader->RestoreL( *tmpStore );

                    TInt originalToRecipientsCount = tmpHeader->ToRecipients().Count(); 

                    TBool present = EFalse;

                    for( TInt i = 0; i < header->CcRecipients().Count(); i++ )

                        {

                        emailAddr = header->CcRecipients()[i].AllocLC(); // ***

                        fsAddr = CFSMailAddress::NewLC(); // ***

                        fsAddr->SetEmailAddress( *emailAddr ); // Copy created

                        present = EFalse;

                        for( TInt j = 0; j < originalToRecipientsCount; j++ )

                            {

                            if( emailAddr->Find( tmpHeader->ToRecipients()[j]) != KErrNotFound )

                                {

                                present = ETrue;

                                break;

                                }

                            }

                        if( present )

                            {

                            newMessage->AppendToRecipient( fsAddr ); // No copy

                            }

                        else

                            {

                            newMessage->AppendCCRecipient( fsAddr ); // No copy

                            }

                        CleanupStack::Pop( fsAddr ); // fsAddr belong now to fsMsg

                        CleanupStack::PopAndDestroy( emailAddr ); // emailAddr not used

                        }

                    CleanupStack::PopAndDestroy( tmpHeader );

                    }

                CleanupStack::PopAndDestroy( 2, tmpEntry );

                // copy bcc recipients

                for( TInt i = 0; i < header->BccRecipients().Count(); i++ )

                    {

                    emailAddr = header->BccRecipients()[i].AllocLC(); // ***

                    fsAddr = CFSMailAddress::NewLC(); // ***

                    fsAddr->SetEmailAddress( *emailAddr ); // Copy created

                    newMessage->AppendBCCRecipient( fsAddr ); // No copy

                    CleanupStack::Pop( fsAddr ); // fsAddr belong now to fsMsg

                    CleanupStack::PopAndDestroy( emailAddr ); // emailAddr not used

                    }

                }

            CleanupStack::PopAndDestroy( 3, cEntry ); // header, store, cEntry

            CleanupStack::Pop( newMessage ); // fsMsg is given to client

            // save the added recipients to the message

            newMessage->SaveMessageL();

            }

        // relay the created message (observer takes ownership)

        SignalFSObserver( iStatus.Int(), newMessage );        

        }

    // nothing left to process, so complete the observer

    TRequestStatus* status = &iObserverRequestStatus;

    User::RequestComplete( status, iStatus.Int() );

    }

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

// CIpsPlgCreateReplyMessageOperation::StartMessageCreationL

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

//

void CIpsPlgCreateReplyMessageOperation::StartMessageCreationL()

    {

    FUNC_LOG;

    delete iOperation;

    iOperation = NULL;

    // Start a new operation, execution continues in RunL 

    // once the operation has finished.

    iOperation = CImEmailOperation::CreateReplyL(

            iStatus, 

            iMsvSession,

            iOriginalMessageId,

            KMsvDraftEntryId, 

            iPartList, 

            KIpsPlgReplySubjectFormat,

            KMsvEmailTypeListMHTMLMessage,

            //0,

            KUidMsgTypeSMTP);

    }

//  End of File

// </qmail>