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


#include "ImapPopulateOperation.h"

//  General includes
#include <eikenv.h>
#include <eikrutil.h>
#include <StringLoader.h>

//  Messaging includes
#include <miut_err.h>
#include <miutset.h>
#include <msvuids.h>
#include <mtmuibas.h>
#include <imapset.h>
#include <Msvprgreporter.H>

#include <imapcmds.h>
#include <imum.rsg>
#include "ImapConnectionOp.h"
#include "MsvConnectionValidation.h"
#include "MsvEmailConnectionProgressProvider.h"
#include "progtype.h"
#include "ImumPanic.h"
#include "ImumMtmLogging.h"
#include "ImapFolderSyncOperation.h"

#include "emailutils.h"

const TInt KImumMaxLoginRetries = 3;
const TInt KImumOperationsArrayGranularity = 2;


// ----------------------------------------------------
// CImapPopulateOp::NewL
// ----------------------------------------------------
CImapPopulateOp* CImapPopulateOp::NewL(
    CMsvSession& aSession,
    TInt aPriority,
    TRequestStatus& aStatus,
    TMsvId aService,
    MMsvProgressReporter& aProgressReporter)
    {
    CImapPopulateOp* me=new (ELeave) CImapPopulateOp(
        aSession, aPriority, aStatus,
        aService, aProgressReporter );
    CleanupStack::PushL(me);
    me->ConstructL();
    CleanupStack::Pop();    //  me
    return me;
    }

// ----------------------------------------------------
// CImapPopulateOp::CImapPopulateOp
// ----------------------------------------------------
CImapPopulateOp::CImapPopulateOp(
    CMsvSession& aSession,
    TInt aPriority,
    TRequestStatus& aStatus,
    TMsvId aService,
    MMsvProgressReporter& aProgressReporter)
    :
    CMsvOperation(aSession, aPriority, aStatus),
    iState(EPopulateConstructing),
    iSyncProgress(),
    iProgressReporter(aProgressReporter)
    {
    iService=aService;
    iMtm=KUidMsgTypeIMAP4;
    iSyncProgress().iType=EImap4SyncProgressType;
    iCoeEnv = CCoeEnv::Static();
    }

    // ----------------------------------------------------
// CImapPopulateOp::~CImapPopulateOp
// ----------------------------------------------------
CImapPopulateOp::~CImapPopulateOp()
    {
    Cancel();
    iProgressReporter.UnsetProgressDecoder();

    //  Release the shared MtmUi
    if(iMtmUi)
        {
        iProgressReporter.MtmStore().ReleaseMtmUi(iMtm);
        }

    delete iConnectionProgressProvider;
    delete iSubOperation;
    delete iTitleText;
    // don't own iCoeEnv so don't delete it
    }

// ----------------------------------------------------
// CImapPopulateOp::ConstructL
// ----------------------------------------------------
void CImapPopulateOp::ConstructL()
    {
    CMsvEntry* serviceEntry=NULL;

    serviceEntry=iMsvSession.GetEntryL(iService);
    CleanupStack::PushL(serviceEntry);

    iSyncProgress().iState=TImap4SyncProgress::EConnecting;
    iSyncProgress().iErrorCode=KErrNone;

    //  Store the related service Id
    iRelatedServiceId=serviceEntry->Entry().iRelatedId;

    iTitleText = StringLoader::LoadL(
        R_EMAIL_CONNECTING_SERVER,
        serviceEntry->Entry().iDetails,
        iCoeEnv );

    CleanupStack::PopAndDestroy( serviceEntry );

    CActiveScheduler::Add(this);

    iObserverRequestStatus=KRequestPending;

    TRequestStatus* myStatus=&iStatus;
    User::RequestComplete(myStatus,KErrNone);

    SetActive();
    //  We complete ourselves so that the dialog gets a chance to redraw
    //  before entering the lengthy process of opening system agent and
    //  connection progress provider
    }


// ----------------------------------------------------
// CImapPopulateOp::RunL
// ----------------------------------------------------
void CImapPopulateOp::RunL()
    {
	DoRunL();
    }

// ----------------------------------------------------
// CImapPopulateOp::DoRunL
// ----------------------------------------------------
void CImapPopulateOp::DoRunL()
    {
    if(iState==EPopulateConstructing)
        {
        FinishConstructionL();
        }
    else
        {
        ConnectionCompletionL();
        }
    }

// ----------------------------------------------------
// CImapPopulateOp::RunError
// ----------------------------------------------------
TInt CImapPopulateOp::RunError(TInt aError)
	{
    iSyncProgress().iErrorCode = aError;
    Complete();		
	}
    
// ----------------------------------------------------
// CImapPopulateOp::FinishConstructionL
// ----------------------------------------------------
void CImapPopulateOp::FinishConstructionL()
    {

    iMtmUi=&(iProgressReporter.MtmStore().ClaimMtmUiL(iMtm));
    iMtmUi->BaseMtm().SwitchCurrentEntryL(iService);


    iConnectionProgressProvider=CMsvEmailConnectionProgressProvider::NewL(
        iMsvSession, iService);

    CImImap4Settings* settings = new(ELeave) CImImap4Settings;
    CleanupStack::PushL( settings );
    CMsvEntry* cEntry = iMsvSession.GetEntryL(iService);
    CleanupStack::PushL( cEntry );
    MsvEmailMtmUiUtils::RestoreSettingsL( *cEntry, *settings );

    TInt bodySizeLimit = settings->BodyTextSizeLimit();

    // -1 for full mail body
    // > 0 for some KB
    // KMaxTInt32 is default value, so no limits set
    if( bodySizeLimit == -1 || bodySizeLimit > 0 || bodySizeLimit < KMaxTInt32 )
        {
        iState = EPopulating;
        iSubOperation = DoPopulateL( *settings );
        CleanupStack::PopAndDestroy(2); // CSI: 47 # settings, cEntry
        }
    else
        {
        CleanupStack::PopAndDestroy(2); // CSI: 47 # settings, cEntry
        }


    SetActive();
    //
    //  We're going to try and connect; tell our MMsvProgressReporter
    //  to come to us for progress.
    //
    iProgressReporter.SetProgressDecoder(*this);

    iObserverRequestStatus=KRequestPending;
    }

// ----------------------------------------------------
// CImapPopulateOp::ConnectionCompletionL
// ----------------------------------------------------
void CImapPopulateOp::ConnectionCompletionL()
    {
    //  Called by RunL when past EPopulateConstructing state
    TInt err=KErrNone;
    if(iSubOperation)
        {
        //  The sub connection operation has completed.

        //  We need to detect a failure to connect due to invalid login details,
        //  and prompt the user accordingly.
        //
        TBuf<CBaseMtmUi::EProgressStringMaxLen> dummyString;
        TInt dummyInt[4]; // CSI: 47 # For dummyInt

        err=DecodeProgress(iSubOperation->ProgressL(),dummyString,dummyInt[0],dummyInt[1],dummyInt[2],dummyInt[3],ETrue); // CSI: 47 # For dummyInts and dummyStrings.
        }


    User::LeaveIfError(err);

    Complete();
    }

// ----------------------------------------------------
// CImapPopulateOp::DoCancel
// ----------------------------------------------------
void CImapPopulateOp::DoCancel()
    {
    if(iSubOperation)
        iSubOperation->Cancel();

    // Unset password.
    if(iResetPassword)
        {
        TRAPD(ignore, MsvConnectionValidation::UnsetPasswordL(iMsvSession,iService));
        }

    iSyncProgress().iErrorCode=KErrCancel;
    Complete();
    }

// ----------------------------------------------------
// CImapPopulateOp::ProgressL
// ----------------------------------------------------
const TDesC8& CImapPopulateOp::ProgressL()
    {
    if(iSubOperation)
        {
        return iSubOperation->ProgressL();
        }
    else
        {
        return iSyncProgress;
        }
    }

// ----------------------------------------------------
// CImapPopulateOp::DecodeProgress
// ----------------------------------------------------
TInt CImapPopulateOp::DecodeProgress(const TDesC8& aProgress,
        TBuf<CBaseMtmUi::EProgressStringMaxLen>& aReturnString,
        TInt& aTotalEntryCount, TInt& aEntriesDone,
        TInt& aCurrentEntrySize, TInt& aCurrentBytesTrans, TBool aInternal)
    {
    if(aProgress.Length()==0)
        return KErrNone;

    TPckgC<TInt> type(0);
    type.Set(aProgress.Left(sizeof(TInt)));

    if(!aInternal || type()!=EUiProgTypeConnecting)
        return iMtmUi->GetProgress(aProgress, aReturnString, aTotalEntryCount,
            aEntriesDone, aCurrentEntrySize, aCurrentBytesTrans);
    return KErrNone;
    }


// ----------------------------------------------------
// CImapPopulateOp::Complete
// ----------------------------------------------------
void CImapPopulateOp::Complete()
    {
    TRequestStatus* observer=&iObserverRequestStatus;
    User::RequestComplete(observer, KErrNone);
    }


CMsvOperation* CImapPopulateOp::DoPopulateL( CImImap4Settings& aSettings )
    {
    iPopulated = ETrue;
    //iStatus = KRequestPending;

    TImImap4GetPartialMailInfo info;

    CMsvEntry* cEntry = iMsvSession.GetEntryL(iService);
    CleanupStack::PushL( cEntry );


    TInt bodySizeLimit = aSettings.BodyTextSizeLimit();
    TInt attaSizeLimit = aSettings.AttachmentSizeLimit();

    info.iBodyTextSizeLimit = bodySizeLimit;
    info.iAttachmentSizeLimit = attaSizeLimit;
    info.iTotalSizeLimit = ( bodySizeLimit + attaSizeLimit );//??
    info.iPartialMailOptions = aSettings.PartialMailOptions();

    TPckg<TImImap4GetPartialMailInfo> param(info);

    CMsvEntrySelection* selection = new(ELeave) CMsvEntrySelection;
    CleanupStack::PushL( selection );
    selection->AppendL( iService );

    TMsvId inbox = FindInboxL( *cEntry );
    selection->AppendL( inbox );

    CMsvOperation* op = iMtmUi->InvokeAsyncFunctionL(
        KIMAP4MTMPopulateNewMailWhenAlreadyConnected,
        //KIMAP4MTMPopulateAllMailWhenAlreadyConnected,
        *selection,
        iStatus,
        param);


    CleanupStack::PopAndDestroy(2); // CSI: 47 # selection, centry

    return op;
    }

TMsvId CImapPopulateOp::FindInboxL( CMsvEntry& aEntry )
    {
    TMsvId inboxId = KErrNotFound;
    TMsvEntry child;
    const TInt count = aEntry.Count();
    _LIT( KTMceUiInboxName, "INBOX");
    for (TInt loop = 0; loop < count && inboxId == KErrNotFound; loop++)
        {
        child = (aEntry)[loop];
        if ( child.iType == KUidMsvFolderEntry  &&
             child.iDetails.CompareF( KTMceUiInboxName ) == 0 )
            {
            inboxId = child.Id();
            }
        }

    return inboxId;
    }

// End of File