/*
* 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:
*       Class implementation file
*
*/


#include <e32base.h>
#include <miut_err.h>
#include "SmtpCopyMoveOp.h"
#include "MsvEmailConnectionProgressProvider.h"
#include "ImumPanic.h"
#include "ImumMtmLogging.h"
#include "EmailUtils.H"
#include "MsvConnectionValidation.h"
#include "ImumMboxSettingsUtils.h"
#include "ImumInMailboxUtilities.h"
#include "SendUiConsts.h"

const TInt KCopyMoveOpPriority = CActive::EPriorityStandard;
const TInt KImumMaxLoginRetries = 3;


// ----------------------------------------------------------------------------
// CSmtpCopyMoveOp::NewL()
// ----------------------------------------------------------------------------
//
CSmtpCopyMoveOp* CSmtpCopyMoveOp::NewL(
    CImumInternalApi& aMailboxApi,
    TRequestStatus& aObserverRequestStatus,
    MMsvProgressReporter& aReporter,
    TMsvId aTarget,
    const CMsvEntrySelection& aSel,
    TBool aMoving )
    {
    IMUM_STATIC_CONTEXT( CSmtpCopyMoveOp::NewL, 0, mtm, KImumMtmLog );
    IMUM_IN();

    CSmtpCopyMoveOp* op = new ( ELeave ) CSmtpCopyMoveOp(
        aMailboxApi, aObserverRequestStatus, aReporter, aTarget, aMoving );
    CleanupStack::PushL( op );
    op->ConstructL( aSel );
    CleanupStack::Pop( op );
    IMUM_OUT();
    return op;
    }

// ----------------------------------------------------------------------------
// CSmtpCopyMoveOp::~CSmtpCopyMoveOp()
// ----------------------------------------------------------------------------
//
CSmtpCopyMoveOp::~CSmtpCopyMoveOp()
    {
    IMUM_CONTEXT( CSmtpCopyMoveOp::~CSmtpCopyMoveOp, 0, KImumMtmLog );
    IMUM_IN();

    delete iEntry;
    delete iSelection;
    delete iProgProvider;
    IMUM_OUT();
    }


// ----------------------------------------------------------------------------
// CSmtpCopyMoveOp::ProgressL()
// ----------------------------------------------------------------------------
//
const TDesC8& CSmtpCopyMoveOp::ProgressL()
    {
    IMUM_CONTEXT( CSmtpCopyMoveOp::ProgressL, 0, KImumMtmLog );
    IMUM_IN();

    if(!iOperation)
        {
        if ( iValidIap )
            {
            IMUM_OUT();
            return iDummyProg;
            }
        else
            {
            TImSmtpProgress& progress = iProgress();
            progress.SetError( KSmtpUnknownErr );
            IMUM_OUT();
            return iProgress;
            }
        }
    TRAPD( err, iProgress.Copy( iOperation->ProgressL() ) );
    // If message is already being sent, ProgressL will leave with KErrNotReady
    // Ignore this error, otherwise progress bar of the second sending
    // will be missing 'Connecting to mailbox...' texts.
    if ( err != KErrNotReady && err != KErrNone )
    	{
		User::Leave( err );
		}
    if ( ( iStatus == KRequestPending ) &&
         ( iProgress().Status() != EMsgOutboxProgressSending ) )
        {
        IMUM_OUT();
        return iProgProvider->GetConnectionProgressL(iError);
        }

    IMUM_OUT();
    return iProgress;
    }


// ----------------------------------------------------------------------------
// CSmtpCopyMoveOp::GetErrorProgressL()
// ----------------------------------------------------------------------------
//
const TDesC8& CSmtpCopyMoveOp::GetErrorProgressL(TInt /*aError*/)
    {
    IMUM_CONTEXT( CSmtpCopyMoveOp::GetErrorProgressL, 0, KImumMtmLog );
    IMUM_IN();
    IMUM_OUT();

    // Never called.
    return iProgress;
    }


// ----------------------------------------------------------------------------
// CSmtpCopyMoveOp::DoRunL()
// ----------------------------------------------------------------------------
//
void CSmtpCopyMoveOp::DoRunL()
    {
    IMUM_CONTEXT( CSmtpCopyMoveOp::DoRunL, 0, KImumMtmLog );
    IMUM_IN();

    if ( ContinueSendingL() )
        {
        InitiateSendingOperationL();
        }
    else
        {
        CompleteObserver( iValidIap ? KErrNone : KSmtpUnknownErr );
        }
    IMUM_OUT();
    }


// ----------------------------------------------------------------------------
// CSmtpCopyMoveOp::CSmtpCopyMoveOp()
// ----------------------------------------------------------------------------
//
CSmtpCopyMoveOp::CSmtpCopyMoveOp(
    CImumInternalApi& aMailboxApi,
    TRequestStatus& aObserverRequestStatus,
    MMsvProgressReporter& aReporter,
    TMsvId aTarget,
    TBool aMoving)
    :
    CImumOnlineOperation(
        aMailboxApi, KCopyMoveOpPriority, aObserverRequestStatus, aReporter ),
    iTarget(aTarget),
    iMoving(aMoving),
    iValidIap( ETrue ), // valid until otherwise stated
    iLoginRetryCounter( 0 )
    {
    IMUM_CONTEXT( CSmtpCopyMoveOp::CSmtpCopyMoveOp, 0, KImumMtmLog );
    IMUM_IN();
    IMUM_OUT();

    }


// ----------------------------------------------------------------------------
// CSmtpCopyMoveOp::ConstructL()
// ----------------------------------------------------------------------------
//
void CSmtpCopyMoveOp::ConstructL(
    const CMsvEntrySelection& aSel )
    {
    IMUM_CONTEXT( CSmtpCopyMoveOp::ConstructL, 0, KImumMtmLog );
    IMUM_IN();

    __ASSERT_ALWAYS( aSel.Count(),
        User::Panic( KImumMtmUiPanic,ESmtpMtmUiEmptySelection ) );
    BaseConstructL( KUidMsgTypeSMTP );

    iEntry = iMsvSession.GetEntryL(aSel[0]);
    iService = iEntry->Entry().iServiceId;
    const TMsvId parent = iEntry->Entry().Parent();

    // To speed up connection establishment, avoid loading settings multiple
    // times. Get all the info needed at once.
    CImumInSettingsData* settings =
        iMailboxApi.MailboxServicesL().LoadMailboxSettingsL( iService );
    CleanupStack::PushL( settings );

    // Get iap name
    TBuf<KImasImailMaxSettingsLength> iapName;
    MsvConnectionValidation::GetServiceIapNameL( *settings,
        KSenduiMtmSmtpUid, iapName);

    TBool ok = ValidateL( *settings );
    CleanupStack::PopAndDestroy(); // settings

    if ( !ok )
        {
        // Will be unable to connect. Complete now.
        SetActive();
        CompleteThis();
        IMUM_OUT();
        return;
        }

    iSelection = aSel.CopyL();

    iProgProvider = CMsvEmailConnectionProgressProvider::NewL( iapName,
        iService );

    iEntry->SetEntryL(parent);
    InitiateSendingOperationL();
    IMUM_OUT();
    }

// ----------------------------------------------------------------------------
// CSmtpCopyMoveOp::ValidateL()
// ----------------------------------------------------------------------------
//
TBool CSmtpCopyMoveOp::ValidateL( CImumInSettingsData& aSettings )
    {
    IMUM_CONTEXT( CSmtpCopyMoveOp::ValidateL, 0, KImumMtmLog );
    IMUM_IN();

    TBool ok = ETrue;
    iEntry->SetEntryL(iService);
    if(!iEntry->Entry().Connected())
        {
        ok = iValidIap = ( aSettings.Validate() == KErrNone );
        }
    IMUM_OUT();
    return ok;
    }

// ----------------------------------------------------------------------------
// CSmtpCopyMoveOp::InitiateSendingOperationL()
// ----------------------------------------------------------------------------
//
void CSmtpCopyMoveOp::InitiateSendingOperationL()
    {
    IMUM_CONTEXT( CSmtpCopyMoveOp::InitiateSendingOperationL, 0, KImumMtmLog );
    IMUM_IN();

    if ( iOperation )
        {
        delete iOperation;
        iOperation = NULL;
        }

    iOperation = MsvEmailMtmUiUtils::DoCEntryCopyMoveL(
        *iEntry, *iSelection, iTarget, iStatus, !iMoving );

    iStatus = KRequestPending;
    SetActive();
    IMUM_OUT();
    }

// ----------------------------------------------------------------------------
// CSmtpCopyMoveOp::GetProgressErrorL()
// ----------------------------------------------------------------------------
//
TInt CSmtpCopyMoveOp::GetProgressErrorL()
    {
    IMUM_CONTEXT( CSmtpCopyMoveOp::GetProgressErrorL, 0, KImumMtmLog );
    IMUM_IN();

    const TPckgBuf<TImSmtpProgress>& progress =
        static_cast<const TPckgBuf<TImSmtpProgress>&>( ProgressL() );
    IMUM_OUT();
    return progress().Error();
    }

// ----------------------------------------------------------------------------
// CSmtpCopyMoveOp::ContinueSendingL()
// ----------------------------------------------------------------------------
//
TBool CSmtpCopyMoveOp::ContinueSendingL()
    {
    IMUM_CONTEXT( CSmtpCopyMoveOp::ContinueSendingL, 0, KImumMtmLog );
    IMUM_IN();

    TInt error = GetProgressErrorL();

    TBool continueSending =
        !( error != KSmtpLoginRefused && error != KSmtpUnknownErr );

    // If login is refused we can try again
    if ( continueSending )
        {
        continueSending = ( iLoginRetryCounter++ < KImumMaxLoginRetries );
        }

    if ( continueSending )
        {
        continueSending =
            MsvConnectionValidation::ShowLoginDetailsRejectionDlgL(
                iMailboxApi, iService );
        }
    IMUM_OUT();

    return continueSending;
    }