/*

* 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: 

*       CImap4MtmUi - IMAP4 MTM UI

*

*/

// Standard includes

//

#include <eikenv.h>//CEikonEnv

#include <StringLoader.h>

#include <avkon.mbg>

//

// Messaging includes

//

#include <mtmuidef.hrh>

#include <mtclreg.h>

#include <mtuireg.h>

#include <eikproc.h>

#include <MuiuMsgEditorLauncher.h>

#include <etel.h> // KErrEtelBusyDetected

#include <bldvariant.hrh>

#include <etelpckt.h>

#include <muiuflagger.h>            // CMuiuFlags

#include <ErrorUI.h> // CErrorUI

#include <mtmdef.h>

#include <smtcmtm.h>

#include <miuthdr.h>

#include <MuiuMsvProgressReporterOperation.h>

#include "PROGTYPE.H"

#include "MsvEmailConnectionProgressProvider.h"

// Specific includes

//

#include "impicmds.h"

#include "ImumPanic.h"

#include <imum.rsg>

#include "IMAPPRGR.H"

#include "Imap4MtmUi.h"

#include <imapset.h>

#include <impcmtm.h>

#include "EmailUtils.H"

#include "EmailFeatureUtils.h"

#include "Imap4ConnectedOp.h"

#include "Imap4FetchOp.h"

#include "Imap4SizeAndFetchOp.h"

#include "Imap4FetchAttachmentOp.h"

#include "Imap4CopyMoveLocalOp.h"

#include "Imap4ConnectedDeleteOp.h"

#include "ImumDeleteMessagesLocally.h"

#include "ImumDeleteMessagesFromServer.h"

#include "RefreshImapFolderList.h"

#include <Muiumsginfo.h>

#include <Muiumsginfo.hrh>

#include "ImumMtmLogging.h"

#include "ImumDisconnectOperation.h"

#include "ImumEditOperation.h"

#include "ImumFetchAndEditOperation.h"

#include "EmailEditorViewerUids.h"

#include "MsvConnectionValidation.h"

#include "IMSSettingsNoteUi.h"

#include <ImumInternalApi.h>        // CImumInternalApi

#include <ImumInHealthServices.h>

#include "ImumListQueryDialog.h"

#include <aknnotewrappers.h>  // CAknNoteDialog

#include <MuiuOperationWait.h>

// Constants

const TInt KImumEntriesDoneReplaceIndex = 0;

const TInt KImumTotalEntriesReplaceIndex = 1;

const TInt KImumProgressBufferLengthSafe = CBaseMtmUi::EProgressStringMaxLen - 10; // 10 is enough to fill message numbers

_LIT(KImpuMtmUiResourceFile, "imum.rsc");

const TUint KForwardSlash = '/';

const TUint KBackSlash = '\\';

const TInt KImumDeleteMessagesLocally = 0;

const TInt KImumMessageInfoBuffer = 32;

const TInt KImumMessagePriorityBufferLength = 32;

const TInt KImumApproxMailFetchSize = 1000;

const TInt KErrDndNameNotFound = -5120;

_LIT( KEmptySpace, " " );

enum TImap4MtmUiOperations

    {

    EImap4MtmUiEditing=EUiProgTypeEditing

    };

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

// CImap4MtmUi::NewIMPUMtmUiL()

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

//

EXPORT_C CBaseMtmUi* NewIMPUMtmUiL(

    CBaseMtm& aMtm,

    CRegisteredMtmDll& aRegisteredDll )

    {

    return CImap4MtmUi::NewL(aMtm, aRegisteredDll);

    }

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

// CImap4MtmUi::NewL()

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

//

CImap4MtmUi* CImap4MtmUi::NewL(

    CBaseMtm& aBaseMtm,

    CRegisteredMtmDll& aRegisteredMtmDll )

    {

    IMUM_STATIC_CONTEXT( CImap4MtmUi::NewL, 0, mtm, KImumMtmLog );

    IMUM_IN();

    CImap4MtmUi* self=new(ELeave) CImap4MtmUi(aBaseMtm, aRegisteredMtmDll);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    IMUM_OUT();

    return self;

    }

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

// CImap4MtmUi::CImap4MtmUi()

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

//

CImap4MtmUi::CImap4MtmUi(CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll)

    :

    CImumMtmBaseMtmUi( aBaseMtm, aRegisteredMtmDll )

    {

    IMUM_CONTEXT( CImap4MtmUi::CImap4MtmUi, 0, KImumMtmLog );

    IMUM_IN();

    IMUM_OUT();

    }

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

// CImap4MtmUi::ConstructL()

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

//

void CImap4MtmUi::ConstructL()

    {

    IMUM_CONTEXT( CImap4MtmUi::ConstructL, 0, KImumMtmLog );

    IMUM_IN();

    CImumMtmBaseMtmUi::ConstructL();

    iEntry = CMsvEntry::NewL(

        Session(), KMsvRootIndexEntryId,

        TMsvSelectionOrdering( KMsvNoGrouping, EMsvSortByNone, ETrue ) );

    iEikonEnv->ReadResourceL( iInboxName, R_INBOX_NAME );

    IMUM_OUT();

    }

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

// CImap4MtmUi::~CImap4MtmUi()

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

//

CImap4MtmUi::~CImap4MtmUi()

    {

    IMUM_CONTEXT( CImap4MtmUi::~CImap4MtmUi, 0, KImumMtmLog );

    IMUM_IN();

    delete iEditorFilename;

    delete iViewerFilename;

    delete iEntry;

    IMUM_OUT();

    }

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

// CImap4MtmUi::GetEditorFileNameL()

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

//

HBufC* CImap4MtmUi::GetEditorFileNameL()

    {

    IMUM_CONTEXT( CImap4MtmUi::GetEditorFileNameL, 0, KImumMtmLog );

    IMUM_IN();

    if(!iEditorFilename)

        {

        iEditorFilename = MsvUiEditorUtilities::ResolveAppFileNameL(KUidMsgInternetMailEditor);

        }

    IMUM_OUT();

    return iEditorFilename;

    }

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

// CImap4MtmUi::GetViewerFileNameL()

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

//

HBufC* CImap4MtmUi::GetViewerFileNameL()

    {

    IMUM_CONTEXT( CImap4MtmUi::GetViewerFileNameL, 0, KImumMtmLog );

    IMUM_IN();

    if(!iViewerFilename)

        {

        iViewerFilename = MsvUiEditorUtilities::ResolveAppFileNameL(KUidMsgInternetMailViewer);

        }

    IMUM_OUT();

    return iViewerFilename;

    }

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

// CImap4MtmUi::CreateL()

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

//

CMsvOperation* CImap4MtmUi::CreateL(

    const TMsvEntry& /*aEntry*/,

    CMsvEntry& /*aParent*/,

    TRequestStatus& /*aStatus*/ )

    {

    IMUM_CONTEXT( CImap4MtmUi::CreateL, 0, KImumMtmLog );

    IMUM_IN();

    User::Leave(KErrNotSupported);

    IMUM_OUT();

    return NULL;

    }

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

// CImap4MtmUi::OpenL()

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

//

CMsvOperation* CImap4MtmUi::OpenL( TRequestStatus& aStatus )

    {

    IMUM_CONTEXT( CImap4MtmUi::OpenL, 0, KImumMtmLog );

    IMUM_IN();

    const TMsvEntry& contextEntry=BaseMtm().Entry().Entry();

    CheckEntryL(contextEntry);

    if (contextEntry.iType == KUidMsvMessageEntry || contextEntry.iType == KUidMsvFolderEntry)

        return EditL(aStatus);

    else if (contextEntry.iType != KUidMsvServiceEntry)

        User::Leave(KErrNotSupported);

    //

    // --- Trying to open a service ---

    const TMsvId owningService=BaseMtm().Entry().OwningService();

    const TInt serviceState=ServiceState(owningService);

    if(!ServiceIsLoaded(serviceState) || ServiceIsDisconnected(serviceState))

        {

        CMsvEntrySelection* sel=new(ELeave) CMsvEntrySelection;

        CleanupStack::PushL(sel);

        sel->AppendL(contextEntry.Id());

        //  Use the UI side connection wrapping operation

        TBuf8<1> dummyParams;

        CMsvOperation* op=InvokeAsyncFunctionL(

            KImpiMTMConnectAndSyncCompleteAfterDisconnection,

            *sel, aStatus, dummyParams);

        CleanupStack::PopAndDestroy();//selection

        IMUM_OUT();

        return op;

        }

    else

        {

        IMUM_OUT();

        //  Can't connect if we're not disconnected

        return CompletedImap4OperationL(owningService, aStatus);

        }

    }

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

// CImap4MtmUi::OpenL()

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

//

CMsvOperation* CImap4MtmUi::OpenL(

    TRequestStatus& aStatus,

    const CMsvEntrySelection& aSelection )

    {

    IMUM_CONTEXT( CImap4MtmUi::OpenL, 0, KImumMtmLog );

    IMUM_IN();

    CheckSelectionL(aSelection);

    IMUM_OUT();

    //

    // --- Edit the message selection ---

    return EditL(aStatus, aSelection);

    }

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

// CImap4MtmUi::CloseL()

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

//

CMsvOperation* CImap4MtmUi::CloseL( TRequestStatus& aStatus )

    {

    IMUM_CONTEXT( CImap4MtmUi::CloseL, 0, KImumMtmLog );

    IMUM_IN();

    const TMsvEntry& contextEntry=BaseMtm().Entry().Entry();

    CheckEntryL(contextEntry);

    // --- Check that current context is a service, all other entry types cannot be closed ---

    if (contextEntry.iType!=KUidMsvServiceEntry)

        User::Leave(KErrNotSupported);

    const TMsvId owningServiceId=BaseMtm().Entry().OwningService();

    TInt serviceState=ServiceState(owningServiceId);

    CMsvOperation* op=NULL;

    if ( !ServiceIsDisconnected(serviceState) && !ServiceIsDisconnecting(serviceState) )

        {

        //  Not disconnected or disconnecting, so try to close service

        CMsvProgressReporterOperation* reporter =

            CMsvProgressReporterOperation::NewL(

                ETrue,

                ETrue,

                Session(),

                aStatus,

                EMbmAvkonQgn_note_progress );

        CleanupStack::PushL(reporter);

        op = CImumDisconnectOperation::NewL(*iMailboxApi, reporter->RequestStatus(), *reporter, contextEntry.Id(), KIMAP4MTMDisconnect, KUidMsgTypeIMAP4);

        reporter->SetOperationL(op); // Takes immediate ownership

        CleanupStack::Pop();    // reporter

        op = reporter;

        }

    IMUM_OUT();

    return op?op:CompletedImap4OperationL(owningServiceId, aStatus);

    }

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

// CImap4MtmUi::CloseL()

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

//

CMsvOperation* CImap4MtmUi::CloseL(

    TRequestStatus& /*aStatus*/,

    const CMsvEntrySelection& /*aSelection*/ )

    {

    IMUM_CONTEXT( CImap4MtmUi::CloseL, 0, KImumMtmLog );

    IMUM_IN();

    // --- Multiple close is not supported ---

    User::Leave(KErrNotSupported);

    IMUM_OUT();

    return NULL;

    }

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

// CImap4MtmUi::WithinIMAPInboxL()

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

//

TBool CImap4MtmUi::WithinIMAPInboxL( TMsvId aEntryId )

    {

    IMUM_CONTEXT( CImap4MtmUi::WithinIMAPInboxL, 0, KImumMtmLog );

    IMUM_IN();

    if (aEntryId==KMsvRootIndexEntryId)

        return EFalse;

    TBool withinInbox=EFalse;

    CMsvEntry* myEntry=Session().GetEntryL(aEntryId);

    CleanupStack::PushL(myEntry);

    if (!(myEntry->OwningService()==KMsvLocalServiceIndexEntryId))

        //  We're not under the local service

        while (!withinInbox && myEntry->Entry().iType!=KUidMsvServiceEntry)

            {

            withinInbox = ( ( myEntry->Entry().iType==KUidMsvFolderEntry ) &&

                ( myEntry->Entry().iDetails.CompareF(iInboxName) == 0 ) );

            myEntry->SetEntryL(myEntry->Entry().Parent());

            }

    CleanupStack::PopAndDestroy();  //  myEntry

    IMUM_OUT();

    return withinInbox;

    }

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

// CImap4MtmUi::CompletedImap4OperationL()

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

//

CMsvOperation* CImap4MtmUi::CompletedImap4OperationL(

    TMsvId aServiceId,

    TRequestStatus& aStatus)

    {

    IMUM_CONTEXT( CImap4MtmUi::CompletedImap4OperationL, 0, KImumMtmLog );

    IMUM_IN();

    TPckgBuf<TImap4UiProgress> newProgressBuf;

    IMUM_OUT();

    return CMsvCompletedOperation::NewL(Imap4BaseMtm()->Session(), Type(), newProgressBuf, aServiceId, aStatus, KErrNone);// KErrNone because we've reported the fact to the user

    }

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

// CImap4MtmUi::EditL()

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

//

CMsvOperation* CImap4MtmUi::EditL( TRequestStatus& aStatus )

    {

    IMUM_CONTEXT( CImap4MtmUi::EditL, 0, KImumMtmLog );

    IMUM_IN();

    CMsvOperation* op=NULL;

    const TMsvEntry& contextEntry=BaseMtm().Entry().Entry();

    CheckEntryL(contextEntry);

    switch (contextEntry.iType.iUid)

        {

    case KUidMsvServiceEntryValue:

        if ( !iMailboxApi->HealthServicesL().IsMailboxHealthy(

            contextEntry.Id() ) )

            {

            User::Leave( KErrNotFound );

            }

        op=EditImap4ServiceL( aStatus, contextEntry.iRelatedId );

        break;

    case KUidMsvMessageEntryValue:

    case KUidMsvFolderEntryValue:

        op=EditL(aStatus, *SingleEntrySelectionLC(contextEntry.Id()));

        CleanupStack::PopAndDestroy();

        break;

    default:

        User::Leave(KErrNotSupported);

        }

    IMUM_OUT();

    return op?op:CompletedImap4OperationL(BaseMtm().Entry().OwningService(), aStatus);

    }

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

// CImap4MtmUi::EditL()

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

//

CMsvOperation* CImap4MtmUi::EditL(

    TRequestStatus& aStatus,

    const CMsvEntrySelection& aSelection )

    {

    IMUM_CONTEXT( CImap4MtmUi::EditL, 0, KImumMtmLog );

    IMUM_IN();

    CMsvOperation* op=NULL;

    iEntry->SetEntryL(aSelection[0]);

    const TMsvId owningService=iEntry->OwningService();

    TMsvEmailEntry tentry=iEntry->Entry();

    switch(iEntry->Entry().iType.iUid)

        {

    case KUidMsvServiceEntryValue:

        BaseMtm().SwitchCurrentEntryL(tentry.Id());

        op=EditL(aStatus);

        break;

    case KUidMsvMessageEntryValue:

        {

        if ( tentry.DisconnectedOperation() == EDisconnectedDeleteOperation )

            {

            // remove deleted flag

            TInt error = MsvEmailMtmUiUtils::RemoveOfflineDeleteL(

                BaseMtm(),

                KIMAP4MTMUndeleteAll,

                tentry.Id() );

            User::LeaveIfError( error );

            }

        if(tentry.iRelatedId==KMsvNullIndexEntryId)

            //  The entry is not a ghost - operate on it directly

            //

            if(tentry.BodyTextComplete())

                {

                op=LaunchMultipleEditorApplicationsL(aSelection, aStatus);

                }

            else

                {

                TEditorParameters editorParams;

                editorParams.iId = aSelection[0];

                editorParams.iFlags &= ~(EMsgLaunchEditorEmbedded | EMsgLaunchEditorThenWait);

                editorParams.iFlags |= EMsgReadOnly;

                const TUint preferences = Preferences();

                if(preferences & EMtmUiFlagEditorPreferEmbedded)

                    {

                    editorParams.iFlags |= EMsgLaunchEditorEmbedded;

                    }

                if(!(preferences & EMtmUiFlagEditorNoWaitForExit))

                    {

                    editorParams.iFlags |= EMsgLaunchEditorThenWait;

                    }

                op = OpenMessageL(aStatus, editorParams);

                }

        else

            {

            //  The entry is a ghost entry - we need to follow the

            //  iRelatedId back to the originator to determine what

            //  we need to do.

            iEntry->SetEntryL(tentry.iRelatedId);

            tentry=iEntry->Entry();

            if(tentry.BodyTextComplete())

                {

                CMsvEntrySelection* mySelection=SingleEntrySelectionLC(tentry.Id());

                op=LaunchMultipleEditorApplicationsL(*mySelection, aStatus);

                CleanupStack::PopAndDestroy();  //  mySelection

                }

            else

                {

                op=OfferSynchroniseL(owningService,aStatus);

                }

            }

        }

        break;

    case KUidMsvFolderEntryValue:

    default:

        User::Leave(KErrNotSupported);

        }

    IMUM_OUT();

    return op?op:CompletedImap4OperationL(owningService, aStatus);

    }

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

// CImap4MtmUi::ViewL()

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

//

CMsvOperation* CImap4MtmUi::ViewL( TRequestStatus& aStatus )

    {

    IMUM_CONTEXT( CImap4MtmUi::ViewL, 0, KImumMtmLog );

    IMUM_IN();

    CMsvOperation* op = NULL;

    TMsvEmailEntry context=BaseMtm().Entry().Entry();

    if (context.iType != KUidMsvMessageEntry)