/*
* 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: 
*       Base class for operations requiring connection
*
*/


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

#include "Imap4ConnectedOp.h"
#include "EmailMsgSizerOperation.h"
#include "EmailUtils.H"
#include "ImumDisconnectOperation.h"
#include "IMAPPRGR.H"
#include "ImumMtmLogging.h"


#include "ImumPanic.h"

// Constants and defines
const TInt KConnectedOpPriority = CActive::EPriorityStandard;
const TInt KConnectedOpConnectPriority = CActive::EPriorityStandard;

CImap4ConnectedOp::~CImap4ConnectedOp()
    {
    IMUM_CONTEXT( CImap4ConnectedOp::~CImap4ConnectedOp, 0, KImumMtmLog );
    IMUM_IN();
    
    delete iConnectedOpErrorProgress;
    IMUM_OUT();
    }

const TDesC8& CImap4ConnectedOp::ProgressL()
    {
    IMUM_CONTEXT( CImap4ConnectedOp::ProgressL, 0, KImumMtmLog );
    IMUM_IN();
    
    if(iConnectedOpErrorProgress && (iState == EStateIdle))
        {
        // Completed, but with an error during connected operation.
        return *iConnectedOpErrorProgress;
        }
    IMUM_OUT();
    return CImumOnlineOperation::ProgressL();
    }

const TDesC8& CImap4ConnectedOp::GetErrorProgressL(TInt aError)
    {
    IMUM_CONTEXT( CImap4ConnectedOp::GetErrorProgressL, 0, KImumMtmLog );
    IMUM_IN();
    
    // Called if DoRunL leaves.
    switch(iState)
        {
        case EStateConnecting:
        case EStateDisconnecting:
            if(!iProgressBuf().iGenericProgress.iErrorCode)
                {
                TImap4CompoundProgress& prog = iProgressBuf();
                prog.iGenericProgress.iState =
                    (iState == EStateConnecting) ?
                    (TImap4GenericProgress::EConnecting) :
                    (TImap4GenericProgress::EDisconnecting);
                prog.iGenericProgress.iErrorCode = aError;
                }
            IMUM_OUT();
            return iProgressBuf;

        case EStateDoingOp:
        case EStateIdle:
        default:
            IMUM_OUT();
            // Call pure virtual function to get progress for the connected operation.
            return ConnectedOpErrorProgressL(aError);

        }
    }

CImap4ConnectedOp::CImap4ConnectedOp(
    CImumInternalApi& aMailboxApi,
    TRequestStatus& aStatus,
    MMsvProgressReporter& aReporter,
    TMsvId aServiceId )
    :
    CImumDiskSpaceObserverOperation(aMailboxApi, KConnectedOpPriority, aStatus, aReporter),
    iConnectionCompletionState(CImapConnectionOp::EWithSyncCompleteAfterFullSync)
    {
    IMUM_CONTEXT( CImap4ConnectedOp::CImap4ConnectedOp, 0, KImumMtmLog );
    IMUM_IN();
    
    iService = aServiceId;
    IMUM_OUT();
    }

void CImap4ConnectedOp::ConstructL( TInt /* aFuncId */ )
    {
    IMUM_CONTEXT( CImap4ConnectedOp::ConstructL, 0, KImumMtmLog );
    IMUM_IN();
    
    BaseConstructL(KUidMsgTypeIMAP4);

    StartL();
    IMUM_OUT();
    }

void CImap4ConnectedOp::StartL()
    {
    IMUM_CONTEXT( CImap4ConnectedOp::StartL, 0, KImumMtmLog );
    IMUM_IN();
    
    CMsvEntry* centry = iMsvSession.GetEntryL(iService);
    iDisconnect = !(centry->Entry().Connected());
    // Only disconnect afterwards if not currently connected.
    delete centry;

    if(iDisconnect)
        {
        iState = EStateConnecting;
        DoConnectL();
        }
    else
        {
        // Already connected, get on with it.
        iState = EStateDoingOp;
        DoConnectedOpL();
        }
    IMUM_OUT();
    }

void CImap4ConnectedOp::RunL()
    {
    IMUM_CONTEXT( CImap4ConnectedOp::RunL, 0, KImumMtmLog );
    IMUM_IN();
    
    const TInt previousError = iError;
    TRAP(iError, DoRunL());	// CSI: 86 # Needed here to properly handle error situations
    if(iError != KErrNone)
        {
        // Need to ensure we disconnect if we have connected.
        if( (iError == KErrNoMemory) || (iState == EStateDisconnecting) )
            {
            // OOM and/or failed to create disconnect operation. Call StopService()
            iMsvSession.StopService(iService);
            // Ignore return, nothing we can do.
            }
        else if( (iState == EStateDoingOp) && (iDisconnect) )
            {
            // Failed to start connected operation. Need to disconnect.
            SetActive();
            CompleteThis();
            IMUM_OUT();
            // Next DoRunL() will attempt to disconnect.
            return;
            }
        CompleteObserver();
        }
    else if(previousError != KErrNone)
        {
        iError = previousError;
        }
    IMUM_OUT();
    }
    
void CImap4ConnectedOp::DoCancel()
    {
    IMUM_CONTEXT( CImap4ConnectedOp::DoCancel, 0, KImumMtmLog );
    IMUM_IN();
    
    CImumOnlineOperation::DoCancel();
    if ( iState == EStateConnecting )
        {
        // Cancelled while doing connected op. Need to disconnect.
        iMsvSession.StopService( iService );
        // Ignore return, nothing we can do.
        }
    IMUM_OUT();
    }

void CImap4ConnectedOp::DoRunL()
    {
    IMUM_CONTEXT( CImap4ConnectedOp::DoRunL, 0, KImumMtmLog );
    IMUM_IN();
    
    switch(iState)
        {
        case EStateConnecting:
            // Connection completed.
            if(GetOperationCompletionCodeL() != KErrNone)
                {
                iState = EStateIdle;
                CompleteObserver();
                }
            else
                {
                iState = EStateDoingOp;
                DoConnectedOpL();
                }
            break;
        case EStateDoingOp:
            // Connected operation completed.
            if(GetOperationCompletionCodeL() != KErrNone)
                {
                // Store the failure progress.
                __ASSERT_DEBUG(!iConnectedOpErrorProgress,
                    User::Panic(KImumMtmUiPanic,EPanicAlreadyHaveErrProg));
                iConnectedOpErrorProgress = iOperation->ProgressL().AllocL();
                }

            /* Background Handling */
            MsvEmailMtmUiUtils::CallNewMessagesL( iService );
            iState = EStateDisconnecting;
            DoDisconnectL();
            break;
        case EStateDisconnecting:
            // Disonnection completed.
            iState = EStateIdle;
            CompleteObserver();
            break;
        case EStateIdle:
        default:
            break;
        }
    if(iOperation)
        {
        iMtm = iOperation->Mtm();
        }
    IMUM_OUT();
    }

void CImap4ConnectedOp::DoConnectL()
    {
    IMUM_CONTEXT( CImap4ConnectedOp::DoConnectL, 0, KImumMtmLog );
    IMUM_IN();
    
    __ASSERT_DEBUG(!iOperation, User::Panic(KImumMtmUiPanic,EPanicOpAlreadySet));
    delete iOperation;
    iOperation = NULL;
    iStatus = KRequestPending;
    iOperation = CImapConnectionOp::NewL(iMailboxApi.MsvSession(), KConnectedOpConnectPriority,
        iStatus, iService, iReporter, iConnectionCompletionState);
    SetActive();
    IMUM_OUT();
    }

void CImap4ConnectedOp::DoDisconnectL()
    {
    IMUM_CONTEXT( CImap4ConnectedOp::DoDisconnectL, 0, KImumMtmLog );
    IMUM_IN();
    
    iStatus = KRequestPending;
    if(iDisconnect)
        {
        delete iOperation;
        iOperation = NULL;
        iOperation = CImumDisconnectOperation::NewL(
            iMailboxApi,
            iStatus,
            iReporter,
            iService,
            KIMAP4MTMDisconnect,
            KUidMsgTypeIMAP4);
        }
    else
        {
        CompleteThis();
        }
    SetActive();
    IMUM_OUT();
    }