/*
* Copyright (c) 2006 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: 
*       Copy or move a selection of messages that may or may not be complete
*
*/


#include <eikenv.h>
#include <eikrutil.h>

#include "Imap4CopyMoveLocalOp.h"
#include "Imap4FetchOp.h"
#include "EmailMsgSizerOperation.h"
#include "EmailUtils.H"
#include "ImumDisconnectOperation.h"
#include <imum.rsg>
#include <imapcmds.h>
#include "IMAPPRGR.H"
#include "ImumMtmLogging.h"
#include "ImumPanic.h"
#include "IMSSettingsNoteUi.h"

const TInt KCopyMoveLocalOpPriority = CActive::EPriorityStandard;


CImap4CopyMoveLocalOp* CImap4CopyMoveLocalOp::NewL(
    CImumInternalApi& aMailboxApi,
    TRequestStatus& aStatus,
    MMsvProgressReporter& aReporter,
    const CMsvEntrySelection& aSel,
    TMsvId aTargetId,
    TBool aCopy)
    {
    IMUM_STATIC_CONTEXT( CImap4CopyMoveLocalOp::NewL, 0, mtm, KImumMtmLog );
    IMUM_IN();
    
    CImap4CopyMoveLocalOp* op = new(ELeave) CImap4CopyMoveLocalOp(
        aMailboxApi, aStatus, aReporter, aTargetId, aCopy);
    CleanupStack::PushL(op);
    op->ConstructL(aSel);
    CleanupStack::Pop();
    IMUM_OUT();
    return op;
    }

CImap4CopyMoveLocalOp::~CImap4CopyMoveLocalOp()
    {
    IMUM_CONTEXT( CImap4CopyMoveLocalOp::~CImap4CopyMoveLocalOp, 0, KImumMtmLog );
    IMUM_IN();
    
    delete iLocalSel;
    delete iRemoteSel;
    IMUM_OUT();
    }

const TDesC8& CImap4CopyMoveLocalOp::GetErrorProgressL(TInt aError)
    {
    IMUM_CONTEXT( CImap4CopyMoveLocalOp::GetErrorProgressL, 0, KImumMtmLog );
    IMUM_IN();
    
    // Called to report a leave in DoRunL()
    if(!iProgressBuf().iGenericProgress.iErrorCode)
        {
        TImap4CompoundProgress& prog = iProgressBuf();
        if(iCopying)
            {
            prog.iGenericProgress.iOperation = TImap4GenericProgress::ECopyToLocal;
            prog.iGenericProgress.iState = TImap4GenericProgress::ECopying;
            }
        else
            {
            prog.iGenericProgress.iOperation = TImap4GenericProgress::EMoveToLocal;
            prog.iGenericProgress.iState = TImap4GenericProgress::EMoving;
            }

        prog.iGenericProgress.iErrorCode = aError;
        }
    IMUM_OUT();
    return iProgressBuf;
    }

void CImap4CopyMoveLocalOp::DoRunL()
    {
    IMUM_CONTEXT( CImap4CopyMoveLocalOp::DoRunL, 0, KImumMtmLog );
    IMUM_IN();
    
    TInt returnValue( KErrNone );
    switch(iState)
        {
        case ELocalMsgs:
            // Local copy complete
            returnValue = GetOperationCompletionCodeL();
            if( returnValue != KErrNone )
                {
                // Failed to copy local messages.
                iState = EIdle;
                CompleteObserver( returnValue );
                }
            else
                {
                DoRemoteFetchL();
                }
            break;
        case ERemoteMsgs:
            // Remote fetch complete.
            iState = EIdle;
            CompleteObserver();
            break;
        case EIdle:
        default:
            break;
        }
    IMUM_OUT();
    }

CImap4CopyMoveLocalOp::CImap4CopyMoveLocalOp(
    CImumInternalApi& aMailboxApi,
    TRequestStatus& aStatus,
    MMsvProgressReporter& aReporter,
    TMsvId aTargetId,
    TBool aCopy)
    :
    CImumDiskSpaceObserverOperation(aMailboxApi, KCopyMoveLocalOpPriority, aStatus, aReporter),
    iCopying(aCopy),
    iTarget(aTargetId)
    {
    IMUM_CONTEXT( CImap4CopyMoveLocalOp::CImap4CopyMoveLocalOp, 0, KImumMtmLog );
    IMUM_IN();
    IMUM_OUT();
    
    }

void CImap4CopyMoveLocalOp::ConstructL(const CMsvEntrySelection& aSel)
    {
    IMUM_CONTEXT( CImap4CopyMoveLocalOp::ConstructL, 0, KImumMtmLog );
    IMUM_IN();
    
    __ASSERT_DEBUG(aSel.Count(),
        User::Panic(KImumMtmUiPanic,EPanicSelectionEmpty));
    if ( aSel.Count() == 0 )
        {
        User::Leave( KErrNotSupported );
        }
    BaseConstructL(KUidMsgTypeIMAP4);
    CMsvEntry* centry = iMsvSession.GetEntryL(aSel[0]);
    iService = centry->OwningService();
    delete centry;
    SortMessageSelectionL(aSel);
    DoLocalCopyMoveL();
    IMUM_OUT();
    }

void CImap4CopyMoveLocalOp::SortMessageSelectionL(const CMsvEntrySelection& aSel)
    {
    IMUM_CONTEXT( CImap4CopyMoveLocalOp::SortMessageSelectionL, 0, KImumMtmLog );
    IMUM_IN();
    
    // Sort messages into complete and incomplete selections.
    __ASSERT_DEBUG(!iLocalSel,
        User::Panic(KImumMtmUiPanic,EPanicSelAlreadyCreated));
    iLocalSel = new(ELeave) CMsvEntrySelection;
    __ASSERT_DEBUG(!iRemoteSel,
        User::Panic(KImumMtmUiPanic,EPanicSelAlreadyCreated));
    iRemoteSel = new(ELeave) CMsvEntrySelection;

    TInt err;
    TMsvId id;
    TMsvId service;
    TMsvEntry tentry;
    for(TInt count=0; count<aSel.Count(); count++)
        {
        id = aSel[count];
        err = iMsvSession.GetEntry(id, service, tentry);
        if(KErrNone == err)
            {
            if(tentry.Complete())
                {
                iLocalSel->AppendL(id);
                }
            else
                {
                iRemoteSel->AppendL(id);
                }
            }
        }
    IMUM_OUT();
    }

void CImap4CopyMoveLocalOp::DoLocalCopyMoveL()
    {
    IMUM_CONTEXT( CImap4CopyMoveLocalOp::DoLocalCopyMoveL, 0, KImumMtmLog );
    IMUM_IN();
    
    iState = ELocalMsgs;
    iStatus = KRequestPending;
    if(iLocalSel->Count())
        {
        CMsvEntry* centry = iMsvSession.GetEntryL((*iLocalSel)[0]);
        CleanupStack::PushL(centry);
        TMsvId parent = centry->Entry().Parent();
        centry->SetEntryL(parent);
        __ASSERT_DEBUG(!iOperation,
            User::Panic(KImumMtmUiPanic,EPanicOpAlreadySet));
        delete iOperation;
        iOperation = NULL;
        iOperation = MsvEmailMtmUiUtils::DoCEntryCopyMoveL(
            *centry, *iLocalSel, iTarget, iStatus, iCopying);
        CleanupStack::PopAndDestroy(); // centry
        }
    else
        {
        CompleteThis();
        }
    SetActive();
    IMUM_OUT();
    }

void CImap4CopyMoveLocalOp::DoRemoteFetchL()
    {
    IMUM_CONTEXT( CImap4CopyMoveLocalOp::DoRemoteFetchL, 0, KImumMtmLog );
    IMUM_IN();
    
    TInt numMsgs = iRemoteSel->Count();
    iState = ERemoteMsgs;
    if(numMsgs)
        {
        CMsvEntry* centry = iMsvSession.GetEntryL(iService);
        TBool doIt = centry->Entry().Connected();
        delete centry;
        if(!doIt)
            {
            numMsgs += iLocalSel->Count();
            iReporter.MakeProgressVisibleL(EFalse);

            // Prompt user before connecting.
            TInt queryResouce =  numMsgs > 1 ?
                R_EMAIL_FETCH_MESSAGES_BEFORE_COPY_QUERY :
                R_EMAIL_FETCH_MESSAGE_BEFORE_COPY_QUERY;
            doIt = CIMSSettingsNoteUi::ShowQueryL(
                queryResouce, R_EMAIL_CONFIRMATION_QUERY );
            }
        if(doIt)
            {
            iReporter.MakeProgressVisibleL(ETrue);
            iStatus = KRequestPending;
            delete iOperation;
            iOperation = NULL;
            TImImap4GetMailInfo getMailInfo;
            getMailInfo.iMaxEmailSize = KMaxTInt32;
            getMailInfo.iGetMailBodyParts = EGetImap4EmailBodyTextAndAttachments;
            getMailInfo.iDestinationFolder = iTarget;

            iOperation = CImap4FetchOp::NewL(
                iMailboxApi,
                iStatus,
                iReporter,
                iService,
                (iCopying?KIMAP4MTMCopyMailSelectionWhenAlreadyConnected:KIMAP4MTMMoveMailSelectionWhenAlreadyConnected),
                getMailInfo,
                *iRemoteSel);
            }
        }
    if(iStatus != KRequestPending)
        {
        CompleteThis();
        }
    SetActive();
    IMUM_OUT();
    }