/*
* 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 CCIpsPlgNewChildPartFromFileOperation.
*
*/

// <qmail>
// INCLUDE FILES

#include "emailtrace.h"
#include "ipsplgheaders.h"

// LOCAL CONSTANTS AND MACROS

_LIT( KMimeTextCalRequest,  "text/calendar; method=REQUEST;" );
_LIT( KMimeTextCalResponse, "text/calendar; method=RESPONSE;" );
_LIT( KMimeTextCalCancel,   "text/calendar; method=CANCEL;" );

_LIT8( KMethod, "method" );
_LIT8( KRequest, "REQUEST" );
_LIT8( KResponse, "RESPONSE" );
_LIT8( KCancel, "CANCEL" );

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

// ----------------------------------------------------------------------------
// CCIpsPlgNewChildPartFromFileOperation::CCIpsPlgNewChildPartFromFileOperation
// ----------------------------------------------------------------------------
//
CCIpsPlgNewChildPartFromFileOperation::CCIpsPlgNewChildPartFromFileOperation(
    CMsvSession& aMsvSession,
    TRequestStatus& aObserverRequestStatus,
    const TFSMailMsgId& aMailBoxId,
    const TFSMailMsgId& aMessageId,
    MFSMailRequestObserver& aOperationObserver,
    const TInt aRequestId)
    :
    CMsvOperation( 
    aMsvSession, 
    CActive::EPriorityStandard, 
    aObserverRequestStatus),
    iMailBoxId(aMailBoxId),
    iMessageId(aMessageId),
    iOperationObserver(aOperationObserver),
    iRequestId(aRequestId)
    {
    FUNC_LOG;
    CActiveScheduler::Add( this );
    }

// ----------------------------------------------------------------------------
// CCIpsPlgNewChildPartFromFileOperation::NewL
// ----------------------------------------------------------------------------
//
CCIpsPlgNewChildPartFromFileOperation* CCIpsPlgNewChildPartFromFileOperation::NewL(
    CMsvSession& aMsvSession,
    TRequestStatus& aObserverRequestStatus,
    const TFSMailMsgId& aMailBoxId,
    const TFSMailMsgId& aMessageId,
    const TDesC& aContentType,
    const TDesC& aFilePath,
    MFSMailRequestObserver& aOperationObserver,
    const TInt aRequestId,
    CIpsPlgMsgMapper *aMsgMapper)
    {
    FUNC_LOG;
    CCIpsPlgNewChildPartFromFileOperation* self =
        new (ELeave) CCIpsPlgNewChildPartFromFileOperation(
            aMsvSession,
            aObserverRequestStatus,
            aMailBoxId,
            aMessageId,
            aOperationObserver,
            aRequestId );
    CleanupStack::PushL( self );
    self->ConstructL(aMsgMapper,aContentType,aFilePath);
    CleanupStack::Pop( self ); 
    return self;
    }

// ----------------------------------------------------------------------------
// CCIpsPlgNewChildPartFromFileOperation::ConstructL
// ----------------------------------------------------------------------------
//
void CCIpsPlgNewChildPartFromFileOperation::ConstructL(CIpsPlgMsgMapper *aMsgMapper,
    const TDesC& aContentType,
    const TDesC& aFilePath)
    {
    FUNC_LOG;
    iMsgMapper = aMsgMapper;
    iStatus = KRequestPending;
    iContentType = aContentType.AllocL();
    iFilePath = aFilePath.AllocL();

    // Start async request in RunL
    iStep = EStep1; // First step
    SetActive();
    iStatus = KRequestPending;
    TRequestStatus* status = &iStatus;
    User::RequestComplete(status,KErrNone);
    }

// ----------------------------------------------------------------------------
// CCIpsPlgNewChildPartFromFileOperation::~CCIpsPlgNewChildPartFromFileOperation
// ----------------------------------------------------------------------------
//
CCIpsPlgNewChildPartFromFileOperation::~CCIpsPlgNewChildPartFromFileOperation()
    {
    FUNC_LOG;
    Cancel(); // Cancel any request, if outstanding
    delete iOperation;
    delete iContentType;
    delete iFilePath;
    }

// ----------------------------------------------------------------------------
// CCIpsPlgNewChildPartFromFileOperation::DoCancel
// ----------------------------------------------------------------------------
//
void CCIpsPlgNewChildPartFromFileOperation::DoCancel()
    {
    FUNC_LOG;
    if (iOperation)
        {
        iOperation->Cancel();
        }
    TRequestStatus* status = &iObserverRequestStatus;
    if ( status && status->Int() == KRequestPending )
        {
        SignalFSObserver( iStatus.Int(), NULL );
        User::RequestComplete( status, iStatus.Int() );
        }
    }

// ----------------------------------------------------------------------------
// CIpsPlgSosBasePlugin::GetMessageEntryL( )
// Checks whether the requested message is already cached. If not, the cached 
// objects are deleted and new objects are created.
// ----------------------------------------------------------------------------
void CCIpsPlgNewChildPartFromFileOperation::GetMessageEntryL( 
    TMsvId aId, 
    CMsvEntry*& aMessageEntry,
    CImEmailMessage*& aImEmailMessage )
    {
    FUNC_LOG;
    if ( !iCachedEntry || ( aId != iCachedEntry->Entry().Id() ) ||
            iCachedEmailMessage->IsActive() )
        {
        CleanCachedMessageEntries();
        
        iCachedEntry = iMsvSession.GetEntryL( aId );
        if ( iCachedEntry->Entry().iType == KUidMsvMessageEntry )
            {
            iCachedEmailMessage = CImEmailMessage::NewL( *iCachedEntry );
            }
        }
    aMessageEntry = iCachedEntry;
    aImEmailMessage = iCachedEmailMessage;
    }

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
//
void CCIpsPlgNewChildPartFromFileOperation::CleanCachedMessageEntries()
    {
    FUNC_LOG;
    delete iCachedEmailMessage;
    iCachedEmailMessage = NULL;
    delete iCachedEntry;
    iCachedEntry = NULL;
    }

// ----------------------------------------------------------------------------
// CCIpsPlgNewChildPartFromFileOperation::RunL
// ----------------------------------------------------------------------------
//
void CCIpsPlgNewChildPartFromFileOperation::RunL()
    {
    if( iStatus.Int() == KErrNone )
        // divided to 4 steps, run asunchronously from 1 to 4
        switch (iStep)
        {
            case EStep1:
                {
                iEntry = NULL;
                iMessage = NULL;
                RFile file;
                TInt fileSize( 0 );

                // Read attachment size
                TRAPD(err,file.Open( iMsvSession.FileSession(), iFilePath->Des(), EFileShareReadersOnly ));
                if (err != KErrNone)
                    {
                    RunError(err);
                    }
             
                //in rare case that file has disappeared while sending
                //we just won't get the size for it
                file.Size( fileSize );
                file.Close();    

                // Initialize CMsvAttachment instance for the attachment creation
                CMsvAttachment* info = CMsvAttachment::NewL( CMsvAttachment::EMsvFile );
                CleanupStack::PushL( info );

                info->SetAttachmentNameL( iFilePath->Des() );
                info->SetSize( fileSize );

                // Create/acquire Symbian message entry objects
                GetMessageEntryL( iMessageId.Id(), iEntry, iMessage );

                // Start attachment creation
                iStatus = KRequestPending;
                iMessage->AttachmentManager().AddAttachmentL( 
                    iFilePath->Des(), info, iStatus );
                CleanupStack::Pop( info ); // attachment manager takes ownership
                iStep = EStep2; // Next step
                SetActive();
                break;
                }
            case EStep2:
                {
                // Dig out the entry ID of the new attachment (unbelievable that
                // there seems to be no better way to do this)
                iMessage->GetAttachmentsListL( iEntry->Entry().Id( ), 
                    CImEmailMessage::EAllAttachments, CImEmailMessage::EThisMessageOnly );
                TKeyArrayFix key( 0, ECmpTInt32 );
                CMsvEntrySelection* attachmentIds = iMessage->Selection().CopyLC();
                attachmentIds->Sort( key );
                if ( !attachmentIds->Count() )
                    {
                    User::Leave( KErrGeneral );
                    }
                iNewAttachmentId = (*attachmentIds)[ attachmentIds->Count()-1 ];
                CleanupStack::PopAndDestroy( attachmentIds );
                
                CMsvEntry* cAtta = iMsvSession.GetEntryL( iNewAttachmentId );
                CleanupStack::PushL( cAtta );
                
                // Set filename to iDetails
                TMsvEntry tEntry = cAtta->Entry();
                tEntry.iDetails.Set(iFilePath->Des());

                // Do async
                iStatus = KRequestPending;
                cAtta->ChangeL( tEntry, iStatus );
                CleanupStack::PopAndDestroy( cAtta );
                iStep = EStep3; // Next step
                SetActive();
                break;
                }
            case EStep3:
                {
                CMsvEntry* cAtta = iMsvSession.GetEntryL( iNewAttachmentId );
                CleanupStack::PushL( cAtta );
                TBool parentToMultipartAlternative( EFalse );
                if( cAtta->HasStoreL() )
                    {
                    CMsvStore* store = cAtta->EditStoreL();
                    CleanupStack::PushL( store );
                    CImMimeHeader* mimeHeader = CImMimeHeader::NewLC();
                    
                    if( store->IsPresentL( KUidMsgFileMimeHeader ) )
                        {
                        mimeHeader->RestoreL( *store );
                        CDesC8Array& array = mimeHeader->ContentTypeParams();
                        array.AppendL( KMethod );
                        parentToMultipartAlternative = ETrue;
                        
                        if( iContentType->Des().Find( KMimeTextCalRequest ) != KErrNotFound )
                            {    
                            array.AppendL( KRequest );
                            }
                        else if( iContentType->Des().Find( KMimeTextCalResponse ) != KErrNotFound )
                            {
                            array.AppendL( KResponse );
                            }
                        else if( iContentType->Des().Find( KMimeTextCalCancel ) != KErrNotFound ) 
                            {
                            array.AppendL( KCancel );
                            }
                        else
                            {
                            parentToMultipartAlternative = EFalse;
                            }
                        mimeHeader->StoreWithoutCommitL( *store );
                        store->CommitL();
                        }
                    
                    CleanupStack::PopAndDestroy( 2, store );
                    }
            
                if( parentToMultipartAlternative &&
                    iFilePath->Find( _L(".ics")) != KErrNotFound )
                    {        
                    TMsvEntry tAttaEntry = cAtta->Entry();
                    TMsvId id = tAttaEntry.Parent();
                    CMsvEntry* cParent = iMsvSession.GetEntryL( id );
                    CleanupStack::PushL( cParent );
                    
                    TMsvEmailEntry tEntry = cParent->Entry();
                    tEntry.SetMessageFolderType( EFolderTypeAlternative );
                    
                    // Do async again if needed
                    iStatus = KRequestPending;
                    cParent->ChangeL( tEntry, iStatus );
                    CleanupStack::PopAndDestroy( cParent );
                    CleanupStack::PopAndDestroy( cAtta );
                    iStep = EStep4; // Next step
                    SetActive();
                    break;
                    }
                CleanupStack::PopAndDestroy( cAtta );
                iStep = EStep4; // Next step
                // Continue to next step wihout break;
                }
            case EStep4:
                {
                // Delete the message entries to get all the changes to disk and 
                // possible store locks released
                CleanCachedMessageEntries();
                
                CFSMailMessagePart* result ( NULL );
                // Create the FS message part object
                result = iMsgMapper->GetMessagePartL( iNewAttachmentId, iMailBoxId, 
                    iMessageId );
                
                // Set attachment name
                result->SetAttachmentNameL(iFilePath->Des());
            
                // store message part
                result->SaveL();
                
                // set flag
                result->SetFlag(EFSMsgFlag_Attachments);
                
                SignalFSObserver(iStatus.Int(),result);
                // nothing left to process, so complete the observer
                TRequestStatus* status = &iObserverRequestStatus;
                User::RequestComplete( status, iStatus.Int() );
                break;
                }
        }
    }

// ----------------------------------------------------------------------------
// CCIpsPlgNewChildPartFromFileOperation::RunError
// ----------------------------------------------------------------------------
//
TInt CCIpsPlgNewChildPartFromFileOperation::RunError(TInt aError)
    {
    FUNC_LOG;
    SignalFSObserver( aError, NULL );
    
    TRequestStatus* status = &iObserverRequestStatus;
    User::RequestComplete( status, aError );
    return KErrNone; // RunError must return KErrNone to active sheduler.
    }

// ----------------------------------------------------------------------------
// CCIpsPlgNewChildPartFromFileOperation::SignalFSObserver
// ----------------------------------------------------------------------------
//
void CCIpsPlgNewChildPartFromFileOperation::SignalFSObserver(
        TInt aStatus, CFSMailMessagePart* aMessagePart )
    {
    FUNC_LOG;
    TFSProgress result =
        { TFSProgress::EFSStatus_Waiting, 0, 0, KErrNone, aMessagePart };
    
    if ( aStatus == KErrCancel )
        {
        result.iProgressStatus = TFSProgress::EFSStatus_RequestCancelled;
        result.iError = KErrCancel;
        }
    else
        {
        result.iProgressStatus = TFSProgress::EFSStatus_RequestComplete;
        result.iError = aStatus;
        }

    TRAP_IGNORE( iOperationObserver.RequestResponseL( result, iRequestId ) );
    }

// ----------------------------------------------------------------------------
// CCIpsPlgNewChildPartFromFileOperation::ProgressL
// ----------------------------------------------------------------------------
//
const TDesC8& CCIpsPlgNewChildPartFromFileOperation::ProgressL()
    {
    FUNC_LOG;
    // Make sure that operation is active
    if ( IsActive() )
        {
        // Get progress
        if ( iOperation )
            {
            return iOperation->ProgressL();
            }
        }
    return iBlank;
    }

//  End of File

// </qmail>