/*

* Copyright (c) 2007-2008 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:  IMAP4 fetch message operation

*

*/

#include "emailtrace.h"

#include "ipsplgheaders.h"

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

EXPORT_C CIpsPlgImap4PopulateOp* CIpsPlgImap4PopulateOp::NewL(

    CMsvSession& aMsvSession,

    TRequestStatus& aObserverRequestStatus,

    TMsvId aService,

    CIpsPlgTimerOperation& aActivityTimer,

    const TImImap4GetPartialMailInfo& aPartialMailInfo,

    const CMsvEntrySelection& aSel,

    TFSMailMsgId aFSMailBoxId,

    TInt aFSRequestId,

    CIpsPlgEventHandler* aEventHandler,

    TBool aDoFilterSelection )

    {

    FUNC_LOG;

    CIpsPlgImap4PopulateOp* op = new (ELeave) CIpsPlgImap4PopulateOp(

        aMsvSession,

        aObserverRequestStatus,

        aService,

        aActivityTimer,

        aPartialMailInfo,

        aFSMailBoxId,

        aFSOperationObserver,

        aFSRequestId,

        aEventHandler );

    CleanupStack::PushL(op);

    op->ConstructL( aSel, aDoFilterSelection );

    CleanupStack::Pop( op );

    return op;

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

CIpsPlgImap4PopulateOp::CIpsPlgImap4PopulateOp(

    CMsvSession& aMsvSession,

    TRequestStatus& aObserverRequestStatus,

    TMsvId aService,

    CIpsPlgTimerOperation& aActivityTimer,

    const TImImap4GetPartialMailInfo& aPartialMailInfo,

    TFSMailMsgId aFSMailBoxId,

    TInt aFSRequestId,

    CIpsPlgEventHandler* aEventHandler )

    :

    CIpsPlgOnlineOperation(

    iPartialMailInfo(aPartialMailInfo),

    {

    FUNC_LOG;

    iService = aService;

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

CIpsPlgImap4PopulateOp::~CIpsPlgImap4PopulateOp()

    {

    FUNC_LOG;

   	delete iTempSelection;

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

    {

    FUNC_LOG;

    BaseConstructL( KUidMsgTypeIMAP4 );

    if ( aDoFilterSelection )

        {

        FilterSelectionL( aSel );

        }

        {

        for ( TInt i = 1; i < aSel.Count(); i++ )

            {

            if ( aSel[i] != iService )

                {

                }

            }

        }

    DoConnectL();

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

    {

    FUNC_LOG;

    return EIpsOpTypeImap4PopulateOp;

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

void CIpsPlgImap4PopulateOp::DoConnectL()

    {

    FUNC_LOG;

    iState = EStateConnecting;

    iStatus = KRequestPending;

    CIpsPlgImap4ConnectOp* connOp = CIpsPlgImap4ConnectOp::NewL(

        iMsvSession,

        iStatus, 

        iService,

        iActivityTimer,

        iFSMailboxId,

        iEventHandler,

    SetActive();

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

void CIpsPlgImap4PopulateOp::RunL()

    {

    FUNC_LOG;

    TRAPD(err, DoRunL());

    if(err != KErrNone )

        {

        iSyncProgress().iErrorCode = err;

        Complete();

        }

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

void CIpsPlgImap4PopulateOp::DoRunL()

    {

    FUNC_LOG;

    TInt err = iStatus.Int();

    switch( iState )

        {

        case EStateConnecting:

            {

            TMsvEntry tentry;

            TMsvId service;

            if( !tentry.Connected() )

                {

                CompleteObserver( KErrCouldNotConnect );

                return;

                }

            DoPopulateL();

            break;

            }

        case EStateFetching:         

            {

                {

                iState = EStateIdle;

                Complete();

                }

            break;

            }

        case EStateInfoEntryChange:

            {

            DoPopulateL();

            break;

            }

        case EStateIdle:

        default:

            break;

        }

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

void CIpsPlgImap4PopulateOp::DoCancel()

    {

    FUNC_LOG;

        {

        }

    CompleteObserver( KErrCancel );

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

const TDesC8& CIpsPlgImap4PopulateOp::ProgressL()

    {

    FUNC_LOG;

    if(iFetchErrorProgress && (iState == EStateIdle))

        {

        // Completed, but with an error during fetch.

        return *iFetchErrorProgress;

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

const TDesC8& CIpsPlgImap4PopulateOp::GetErrorProgressL(TInt /*aError*/ )

    {

    FUNC_LOG;

    return *iFetchErrorProgress;

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

TFSProgress CIpsPlgImap4PopulateOp::GetFSProgressL() const

    {

    FUNC_LOG;

    // might not never called, but gives something reasonable if called

    TFSProgress result = { TFSProgress::EFSStatus_Waiting, 0, 0, KErrNone };

    switch( iState )

        {

        case EStateConnecting:

            result.iProgressStatus = TFSProgress::EFSStatus_Connecting;

            break;

        case EStateFetching:

            result.iProgressStatus = TFSProgress::EFSStatus_Connected;

            break;

        default:

            result.iProgressStatus = TFSProgress::EFSStatus_RequestComplete;

            break;

        }

    if ( iStatus.Int() == KErrCancel )

        {

        result.iProgressStatus = TFSProgress::EFSStatus_RequestCancelled;

        result.iError = KErrCancel;

        }

    return result;

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

void CIpsPlgImap4PopulateOp::Complete()

    {

    FUNC_LOG;

    TRequestStatus* observer=&iObserverRequestStatus;

    User::RequestComplete(observer, KErrNone);

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

    {

    FUNC_LOG;

    TMsvId messageId;

        {

        if ( messageId == iService )

            {

            }

        TMsvEmailEntry entry;

        TBool isComplete = !(   ( entry.Complete() && entry.PartialDownloaded() ) 

                             || ( !entry.Complete() && ( !entry.BodyTextComplete() 

                             || ( iPartialMailInfo.iGetMailBodyParts == EGetImap4EmailBodyTextAndAttachments ) ) 

                                  && !entry.PartialDownloaded() ) );

        TBool isMsgEntry = entry.iType == KUidMsvMessageEntry;

        TBool isSizeUnderMax = entry.iSize <= iPartialMailInfo.iMaxEmailSize;

            {

            }

        else if ( isMsgEntry && isSizeUnderMax && !isParentComp )

            {

            }

        }

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

TBool CIpsPlgImap4PopulateOp::IsPartialPopulate( )

    {

    FUNC_LOG;

        {

        isPartialPopulate = EFalse;

        }

    else

        {

        isPartialPopulate = ETrue;

        }

    return isPartialPopulate;

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

void CIpsPlgImap4PopulateOp::DoPopulateL( )

    {

    FUNC_LOG;

        {

        TMsvEmailEntry tEntry;

        TMsvId dummy;

        iState = EStateFetching;

        iTempSelection->Reset();

        iTempSelection->AppendL( iService );

        // Filters are not used when performing 'fetch'

        // operation, use normal getmail info instead

        iBaseMtm->SwitchCurrentEntryL( iService );

        iState = EStateInfoEntryChange;

        SetActive();

        }

    else

        {

        iState = EStateIdle;

        CompleteObserver();

        }

    }