/*
* 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: 
*       SMTP Create New Email operation
*
*/

#include <eikenv.h>
#include <miuthdr.h>
#include <smtpset.h>
#include <MTMStore.h>
#include <muiumsvuiserviceutilitiesinternal.h>
#include <MsvPrgReporter.h>
#include <SendUiConsts.h>
#include "ImumMtmLogging.h"
#include "SmtpCreateNewOp.h"
#include "SmtpTimerOp.h"
#include "EmailPreCreation.h"
#include "MsvConnectionValidation.h"
#include "MsvEmailConnectionProgressProvider.h"
#include "EmailUtils.H"


const TInt KNewMsgOpPriority = CActive::EPriorityStandard;
const TInt KIntervalAfterEditorLaunch = 100000; // 0.1 seconds

// ----------------------------------------------------------------------------
// NewL
// ----------------------------------------------------------------------------
CSmtpCreateNewOp* CSmtpCreateNewOp::NewL(
    CImumInternalApi& aMailboxApi,
    TRequestStatus& aObserverRequestStatus,
    const TEditorParameters& aParams,
    const TDesC& aAppName,
    const TDesC8& aEditorProgress)
    {
    IMUM_STATIC_CONTEXT( CSmtpCreateNewOp::NewL, 0, mtm, KImumMtmLog );
    IMUM_IN();
    
    CSmtpCreateNewOp* op = new(ELeave) CSmtpCreateNewOp(
        aMailboxApi, aObserverRequestStatus, aParams, aAppName);
    CleanupStack::PushL(op);
    op->ConstructL(aEditorProgress);
    CleanupStack::Pop();
    IMUM_OUT();
    return op;
    }

// ----------------------------------------------------------------------------
// ~CSmtpCreateNewOp
// ----------------------------------------------------------------------------
CSmtpCreateNewOp::~CSmtpCreateNewOp()
    {
    IMUM_CONTEXT( CSmtpCreateNewOp::~CSmtpCreateNewOp, 0, KImumMtmLog );
    IMUM_IN();
    
    delete iEditorProgress;
    IMUM_OUT();
    }

// ----------------------------------------------------------------------------
// RunL
// ----------------------------------------------------------------------------
void CSmtpCreateNewOp::RunL()
    {
    IMUM_CONTEXT( CSmtpCreateNewOp::RunL, 0, KImumMtmLog );
    IMUM_IN();
    
    DoRunL();
    
    IMUM_OUT();
    }

// ----------------------------------------------------------------------------
// RunL
// ----------------------------------------------------------------------------
TInt CSmtpCreateNewOp::RunError(TInt aError)
	{
    IMUM_CONTEXT( CSmtpCreateNewOp::RunError, 0, KImumMtmLog );
    IMUM_IN();
	
	IMUM1( 0, "RunL leaved with error code %d", aError );
	
    if( iState == EStateLaunch || iState == EStateDeleteAll || iState == EStateCreateNew )
        {
        iProgress().iError = aError;
        iProgress().iType = TMsvLocalOperationProgress::ELocalNew;
        iProgress().iTotalNumberOfEntries = 1;
        iProgress().iNumberFailed = 1;
        }
    iMtm = KUidMsvLocalServiceMtm;
    CompleteObserver();	
    
    IMUM_OUT();	
    
    return KErrNone;
	}
 
// ----------------------------------------------------------------------------
// DoRunL
// ----------------------------------------------------------------------------
void CSmtpCreateNewOp::DoRunL()
    {
    IMUM_CONTEXT( CSmtpCreateNewOp::DoRunL, 0, KImumMtmLog );
    IMUM_IN();
    
    TInt err = KErrNone;
    TPckgBuf<TMsvId> idbuf;
    if(iStatus.Int() != KErrNone)
        {
        err = iStatus.Int();
        }
    else if(iOperation)
        {
        const TDesC8& prog = iOperation->ProgressL();
        if(prog.Length())
            {
            if(iState == EStateCreate || iState == EStateCreateNew)
                {
                idbuf.Copy(prog.Left(sizeof(TMsvId)));
                if(idbuf() == KMsvNullIndexEntryId)
                    {
                    err = KErrGeneral;
                    }
                }
            else
                {
                const TUid uid(iOperation->Mtm());
                if(uid == KUidMsvLocalServiceMtm)
                    {
                    err = McliUtils::GetLocalProgressL(*iOperation).iError;
                    }
                else
                    {
                    TBuf<CBaseMtmUi::EProgressStringMaxLen> retString;
                    TInt totalEntryCount = 0;
                    TInt entriesDone = 0;
                    TInt currentEntrySize = 0;
                    TInt currentBytesTrans = 0;
                    err = iMtmStore->ClaimMtmUiL(uid).GetProgress(
                        prog,
                        retString,
                        totalEntryCount,
                        entriesDone,
                        currentEntrySize,
                        currentBytesTrans);
                    iMtmStore->ReleaseMtmUi(uid);
                    }
                }
            }
        }
    if(iOperation)
        {
        delete iOperation;
        iOperation = NULL;
        }
    User::LeaveIfError(err); // Caught in RunL()

    switch(iState)
        {
    case EStateIdle:
    case EStateCreateNew:
        LaunchEditorL();
        break;
    case EStateDeleteAll:
        CreateMessageL( ETrue );
        break;
    case EStateLaunch:
    case EStateWait:
        CreateMessageL();
        break;
    case EStateCreate:
        CompleteObserver();
        break;
    default:
        break;
        }
    iMtm = (iOperation) ? (iOperation->Mtm()) : (KUidMsvLocalServiceMtm);
    IMUM_OUT();
    }

// ----------------------------------------------------------------------------
// CSmtpCreateNewOp
// ----------------------------------------------------------------------------
CSmtpCreateNewOp::CSmtpCreateNewOp(
    CImumInternalApi& aMailboxApi,
    TRequestStatus& aObserverRequestStatus,
    const TEditorParameters& aParams,
    const TDesC& aAppName)
    :   
    CSmtpPreCreationOpBase(
        aMailboxApi.MsvSession(), KNewMsgOpPriority, aObserverRequestStatus ),    
    iParams(aParams),
    iAppName(aAppName)
    {
    IMUM_CONTEXT( CSmtpCreateNewOp::CSmtpCreateNewOp, 0, KImumMtmLog );
    IMUM_IN();
    IMUM_OUT();
    
    }

// ----------------------------------------------------------------------------
// ConstructL
// ----------------------------------------------------------------------------
void CSmtpCreateNewOp::ConstructL(const TDesC8& aEditorProgress)
    {
    IMUM_CONTEXT( CSmtpCreateNewOp::ConstructL, 0, KImumMtmLog );
    IMUM_IN();
    
    CSmtpPreCreationOpBase::ConstructL();
    iEditorProgress = aEditorProgress.AllocL();
    if(iParams.iFlags & EMsgCreateMessageToService)
        {
        // Context sensitive service.
        iService = iParams.iId;
        }
    else
        {
        iService = MsvUiServiceUtilitiesInternal::DefaultServiceForMTML(
            iMsvSession, KUidMsgTypeSMTP, ETrue);
        }
    iStatus = KRequestPending;
    SetActive();
    CompleteThis();
    iState = EStateIdle;
    IMUM_OUT();
    }

// ----------------------------------------------------------------------------
// LaunchEditorL
// ----------------------------------------------------------------------------
void CSmtpCreateNewOp::LaunchEditorL()
    {
    IMUM_CONTEXT( CSmtpCreateNewOp::LaunchEditorL, 0, KImumMtmLog );
    IMUM_IN();
    
    TMsvId id = iPreCreate->FindPreCreatedEmailL(iService, KMsvNullIndexEntryId);
    if(id != KMsvNullIndexEntryId)
        {
        // Adjust editor parameters for editing existing message.
        iParams.iFlags &= ~(EMsgCreateNewMessage | EMsgCreateMessageToService);
        iParams.iFlags |= EMsgEditNewMessage;
        iParams.iId = id;
        }
    iStatus = KRequestPending;
    iOperation = NULL;

    TRAPD( error, iOperation = MsgEditorLauncher::LaunchEditorApplicationL(
        iMsvSession,
        TUid::Uid( KSenduiMtmSmtpUidValue ),
        iStatus,
        iParams,
        iAppName,
        *iEditorProgress) );

    if ( error == KErrNotFound && iState == EStateIdle )
        {
        // try to recover from the situation where precreated mail is corrupted.
        iOperation = iPreCreate->DeleteAllPreCreatedEmailsL( iService, iStatus );
        iState = EStateDeleteAll;
        }
    else
        {
        if ( error != KErrNone )
            {
            User::Leave( KErrCancel );    
            }
        iState = EStateLaunch;
        }

    SetActive();
    IMUM_OUT();
    }

// ----------------------------------------------------------------------------
// WaitL
// ----------------------------------------------------------------------------
void CSmtpCreateNewOp::WaitL()
    {
    IMUM_CONTEXT( CSmtpCreateNewOp::WaitL, 0, KImumMtmLog );
    IMUM_IN();
    
    iStatus = KRequestPending;
    CSmtpTimerOp* op = new(ELeave) CSmtpTimerOp(
        iMailboxApi->MsvSession(), CActive::EPriorityIdle, iStatus);
    CleanupStack::PushL(op);
    op->ConstructL();
    op->After(TTimeIntervalMicroSeconds32(KIntervalAfterEditorLaunch));
    CleanupStack::Pop(op);
    iOperation = op;
    SetActive();
    iState = EStateWait;
    IMUM_OUT();
    }

// ----------------------------------------------------------------------------
// CreateMessageL
// ----------------------------------------------------------------------------
void CSmtpCreateNewOp::CreateMessageL( TBool aLaunchEditorAfterCreate /*= EFalse*/ )
    {
    IMUM_CONTEXT( CSmtpCreateNewOp::CreateMessageL, 0, KImumMtmLog );
    IMUM_IN();
    
    // Only create if there isn't a message there already.
    iStatus = KRequestPending;
    if(iPreCreate->FindPreCreatedEmailL(iService, iParams.iId) == KMsvNullIndexEntryId)
        {
        iOperation = iPreCreate->PreCreateBlankEmailL(iService, iStatus);
        }
    else
        {
        CompleteThis();
        }
    SetActive();
    iState = aLaunchEditorAfterCreate ? EStateCreateNew: EStateCreate;
    IMUM_OUT();
    }

// End of File