/*

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

*       POP3 MTM UI

*

*/

// Standard includes

#include <txtrich.h>                        // CRichText

#include <apacmdln.h>                       // CApaCommandLine

#include <apgcli.h>

#include <apaid.h>

#include <eikdialg.h>                       // CEikDialog

#include <eikon.hrh>

#include <eikenv.h>                         // CEikonEnv

#include <eikrutil.h>                       // EikResourceUtils

#include <aknlistquerydialog.h>

#include <aknPopupHeadingPane.h>            // CAknPopupHeadingPane

#include <ErrorUI.h>                        // CErrorUI

#include <StringLoader.h>

#include <etel.h>                           // KErrEtelBusyDetected

#include <bldvariant.hrh>

#include <etelpckt.h>

// Messaging includes

#include <mtclreg.h>

#include <mtuireg.h>

#include <mtmuidef.hrh>

#include <pops.h>

#include <pop3set.h>

#include <smtpset.h>

#include <miutset.h>

#include <MuiuMsvProgressReporterOperation.h>

#include <avkon.mbg>                        // bitmaps for progress

#include <MuiuOperationWait.h>

// Specific includes

#include "ImumPanic.h"

#include <imum.rsg>

#include "Pop3MtmUi.h"

#include <mtmdef.h>

#include <msvids.h>

#include "PROGTYPE.H"

#include "MsvEmailConnectionProgressProvider.h"

#include "EmailUtils.H"

#include "EmailFeatureUtils.h"

#include <muiuflagger.h>                    // CMuiuFlags

#include "ImumDisconnectOperation.h"

#include "ImumEditOperation.h"

#include "ImumFetchAndEditOperation.h"

#include <MTMStore.h>

#include "ImumOnlineOperation.h"

#include "ImumDeleteMessagesLocally.h"

#include "ImumDeleteMessagesFromServer.h"

#include "MsvPop3ConnectOp.h"

#include "MsvPop3FetchOperation.h"

#include "MsvPop3CopyMoveOperation.h"

#include <MtmExtendedCapabilities.hrh>

#include <Muiumsginfo.h>

#include <Muiumsginfo.hrh>

#include "EmailEditorViewerUids.h"

#include <aknnotewrappers.h>                // CAknNoteDialog

#include "IMSSettingsNoteUi.h"

#include <ImumInternalApi.h>        // CImumInternalApi

#include <ImumInHealthServices.h>

#include "ImumMtmLogging.h"

#include "ImumListQueryDialog.h"

// prevents warning with TRefByValue in WINS REL

#pragma warning (disable : 4710)	// CSI: 47 # Needed for disable warning.

// Constants

const TInt KPop3MtmUiDeleteMessagesLocally = 0;

const TInt KImumEntriesDoneReplaceIndex = 0;

const TInt KImumTotalEntriesReplaceIndex = 1;

// Convenience function IDs for FetchL().

const TInt KFunctionIdFetchSelected = KPOP3MTMCopyMailSelectionWhenAlreadyConnected;

const TInt KFunctionIdFetchAll = KPOP3MTMCopyAllMailWhenAlreadyConnected;

const TInt KFunctionIdFetchNew = KPOP3MTMCopyNewMailWhenAlreadyConnected;

const TInt KImumMessageInfoDateBufferLength = 30;

const TInt KImumMessageInfoSizeBufferLength = 20;

const TInt KImumMessagePriorityBufferLength = 32;

const TInt KImumMaxCharsInLine = 75;

const TInt KImumKB = 1024;

const TInt KErrDndNameNotFound = -5120;

// Defines

_LIT( KPop3uMtmUiResourceFile, "imum.rsc" );

//////////////////////

// Factory function //

//////////////////////

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

// NewPP3UMtmUiL()

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

//

EXPORT_C CBaseMtmUi* NewPP3UMtmUiL(CBaseMtm& aMtm, CRegisteredMtmDll& aRegisteredDll)

    {

    return CPop3MtmUi::NewL(aMtm, aRegisteredDll);

    }

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

// CPop3MtmUi::NewL()

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

//

CPop3MtmUi* CPop3MtmUi::NewL(CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll)

    {

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

    IMUM_IN();

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    IMUM_OUT();

    return self;

    }

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

// CPop3MtmUi::CPop3MtmUi(()

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

//

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

    :

    CImumMtmBaseMtmUi(aBaseMtm, aRegisteredMtmDll)

    {

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

    IMUM_IN();

    IMUM_OUT();

    }

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

// CPop3MtmUi::ConstructL()

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

//

void CPop3MtmUi::ConstructL()

    {

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

    IMUM_IN();

    // --- Make sure base class correctly constructed ---

    CImumMtmBaseMtmUi::ConstructL();

    iServerNameCache.iService = KMsvNullIndexEntryId;

    IMUM_OUT();

    }

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

// CPop3MtmUi::GetEditorFileNameL()

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

//

HBufC* CPop3MtmUi::GetEditorFileNameL()

    {

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

    IMUM_IN();

    if(!iEditorFilename)

        {

        iEditorFilename = MsvUiEditorUtilities::ResolveAppFileNameL(

            KUidMsgInternetMailEditor);

        }

    IMUM_OUT();

    return iEditorFilename;

    }

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

// CPop3MtmUi::GetViewerFileNameL()

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

//

HBufC* CPop3MtmUi::GetViewerFileNameL()

    {

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

    IMUM_IN();

    if(!iViewerFilename)

        {

        iViewerFilename = MsvUiEditorUtilities::ResolveAppFileNameL(

            KUidMsgInternetMailViewer);

        }

    IMUM_OUT();

    return iViewerFilename;

    }

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

// ::~CPop3MtmUi()()

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

//

CPop3MtmUi::~CPop3MtmUi()

    {

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

    IMUM_IN();

    delete iEditorFilename;

    delete iViewerFilename;

    IMUM_OUT();

    }

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

// CPop3MtmUi::CreateL()

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

//

CMsvOperation* CPop3MtmUi::CreateL(

    const TMsvEntry& aEntry,

    CMsvEntry& aParent,

    TRequestStatus& aStatus)

    {

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

    IMUM_IN();

    // Context is irrelevant.

    aStatus=KRequestPending;

    // Make sure the entry is a service, since POP3 doesn't support folders

    // and POP3 messages / attachments are only created by the engine components

    if (aEntry.iType.iUid!=KUidMsvServiceEntryValue)

        User::Leave(KErrNotSupported);

    //

    // Since services can only be created from the root, make sure the requested parent is root

    __ASSERT_ALWAYS(aParent.Entry().Id()==KMsvRootIndexEntryId, User::Panic(KImumMtmUiPanic, EPop3MtmUiParentNotRoot));

    //

    // Create an SMTP service entry

    TMsvEntry smtpService(aEntry);

    smtpService.iMtm=KUidMsgTypeSMTP;

    smtpService.SetVisible(EFalse);

    aParent.CreateL(smtpService);

    IMUM_OUT();

    //

    // POP3 MTMUI defers set-up to the SMTP MTMUI, so create an SMTP mtmui and edit a service with it

    return EditSmtpServiceL(aStatus, smtpService.Id());

    }

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

// CPop3MtmUi::OpenL()

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

//

CMsvOperation* CPop3MtmUi::OpenL(TRequestStatus& aStatus)

    {

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

    IMUM_IN();

    // Context is the entry to open.

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

    CheckEntryL(contextEntry);

    if(contextEntry.iType.iUid == KUidMsvMessageEntryValue)

        {

        IMUM_OUT();

        return EditL(aStatus);

        }

    // Entry is a service.

    /*Check if partial fetch should be used*/

    /*

    const TMsvId serviceId = contextEntry.Id();

    const CImPop3Settings& settings = GetAccountSettingsL(serviceId);

    TInt limit = settings.PopulationLimit();

    TInt functionID = KPOP3MTMConnect;

    // n lines of message to be fetched. or full message.

    if( limit == EFullBody || ( limit >= EUserDefinedKB && limit < KMaxTInt32 ) )

        {

        functionID = KPOP3MTMPopulateAll;

        }

        */

    TBuf8<1> dummyParams;

    dummyParams.Zero();

    CMsvEntrySelection* sel=new(ELeave) CMsvEntrySelection;

    CleanupStack::PushL(sel);

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

    CMsvOperation* op = InvokeAsyncFunctionL(

        KPOP3MTMConnect, *sel, aStatus, dummyParams);

    CleanupStack::PopAndDestroy();//sel

    IMUM_OUT();

    return op;

    }

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

// CPop3MtmUi::OpenL()

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

//

CMsvOperation* CPop3MtmUi::OpenL(

    TRequestStatus& aStatus,

    const CMsvEntrySelection& aSelection)

    {

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

    IMUM_IN();

    // Context is irrelevant.

    TMsvId selectionParent=KMsvNullIndexEntryId;

    CheckSelectionL(aSelection, selectionParent);

    // Edit the message selection

    IMUM_OUT();

    return EditL(aStatus, aSelection);

    }

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

// CPop3MtmUi::CloseL()

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

//

CMsvOperation* CPop3MtmUi::CloseL(TRequestStatus& aStatus)

    {

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

    IMUM_IN();

    // Context is the entry to close.

    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);

        }

    // Disconnect the service

    aStatus=KRequestPending;

    if(Session().ServiceActive(contextEntry.Id()))

        {

        IMUM_OUT();

        // Service is busy

        return CMsvCompletedOperation::NewL(

            Session(),

            Type(),

            KNullDesC8,

            KMsvLocalServiceIndexEntryId,

            aStatus,

            KErrNone);// KErrNone because we've reported the fact to the user

        }

    CMsvEntrySelection* sel=SingleEntrySelectionLC(contextEntry.Id());

    TBuf8<1> buf;

    buf.Zero();

    CMsvOperation* op=InvokeAsyncFunctionL(KPOP3MTMDisconnect, *sel, aStatus, buf);

    CleanupStack::PopAndDestroy();//selection

    IMUM_OUT();

    return op;

    }

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

// CPop3MtmUi::CloseL()

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

//

CMsvOperation* CPop3MtmUi::CloseL(

    TRequestStatus& /*aStatus*/,

    const CMsvEntrySelection& /*aSelection*/)

    {

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

    IMUM_IN();

    // Multiple close is not supported

    User::Leave(KErrNotSupported);

    IMUM_OUT();

    return NULL;

    }

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

// CPop3MtmUi::EditL()

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

//

CMsvOperation* CPop3MtmUi::EditL(TRequestStatus& aStatus)

    {

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

    IMUM_IN();

    // Context is the entry to edit.

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

    CheckEntryL(contextEntry);

    // Edit service (mailbox)

    if(contextEntry.iType.iUid==KUidMsvServiceEntryValue)

        {

        TMsvEntry mailbox = BaseMtm().Entry().Entry();

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

            {

            User::Leave( KErrNotFound );

            }    

        return EditSmtpServiceL(aStatus, mailbox.iRelatedId);

        }

    IMUM_OUT();

    // Edit message

    return ViewMessageL(aStatus);

    // POP3 messages are always read only, so actually we are viewing the message.

    }

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

// CPop3MtmUi::EditL()

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

//

CMsvOperation* CPop3MtmUi::EditL(

    TRequestStatus& aStatus,

    const CMsvEntrySelection& aSelection)

    {

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

    IMUM_IN();

    // Context is irrelevant.

    // Only the first message in the selection is editted.

    __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, EPop3MtmUiSelectionIsEmpty));

    BaseMtm().Entry().SetEntryL(aSelection[0]);

    IMUM_OUT();

    return EditL(aStatus);

    }

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

// CPop3MtmUi::ViewL()

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

//

CMsvOperation* CPop3MtmUi::ViewL(TRequestStatus& aStatus)

    {

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

    IMUM_IN();

    // Context is the message to view.

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

    CheckEntryL(context);

    // Can only view message entries

    if(context.iType.iUid != KUidMsvMessageEntryValue)

        {

        User::Leave(KErrNotSupported);

        }

    IMUM_OUT();

    return ViewMessageL(aStatus);

    }

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

// CPop3MtmUi::ViewL()

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

//

CMsvOperation* CPop3MtmUi::ViewL(

    TRequestStatus& aStatus,

    const CMsvEntrySelection& aSelection)

    {

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

    IMUM_IN();

    // Context is irrelevant.

    // Only the first message in the selection is viewed.

    __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, EPop3MtmUiSelectionIsEmpty));

    BaseMtm().Entry().SetEntryL(aSelection[0]);

    IMUM_OUT();

    return ViewL(aStatus);

    }

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

// CPop3MtmUi::CancelL()

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

//

CMsvOperation* CPop3MtmUi::CancelL(

    TRequestStatus& /*aStatus*/,

    const CMsvEntrySelection& /*aSelection*/)

    {

    IMUM_CONTEXT( CPop3MtmUi::CancelL, 0, KImumMtmLog );

    IMUM_IN();

    // Currently this function only used to suspend messages queued for sending.

    // Can't send POP3 messages, so can't cancel them either.

    User::Leave(KErrNotSupported);

    IMUM_OUT();

    return NULL;

    }

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

// CPop3MtmUi::CopyToL()

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

//

CMsvOperation* CPop3MtmUi::CopyToL(

    const CMsvEntrySelection& /*aSelection*/,

    TRequestStatus& /*aStatus*/)

    {

    IMUM_CONTEXT( CPop3MtmUi::CopyToL, 0, KImumMtmLog );

    IMUM_IN();

    __ASSERT_DEBUG( EFalse, User::Panic(KImumMtmUiPanic, EPop3MtmUiCannotCopyOrMoveToRemote));

    User::Leave(KErrNotSupported);

    IMUM_OUT();

    return NULL;

    }

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

// CPop3MtmUi::MoveToL()

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

//

CMsvOperation* CPop3MtmUi::MoveToL(

    const CMsvEntrySelection& /*aSelection*/,

    TRequestStatus& /*aStatus*/)

    {

    IMUM_CONTEXT( CPop3MtmUi::MoveToL, 0, KImumMtmLog );

    IMUM_IN();

    __ASSERT_DEBUG( EFalse, User::Panic(KImumMtmUiPanic, EPop3MtmUiCannotCopyOrMoveToRemote));

    User::Leave(KErrNotSupported);

    IMUM_OUT();

    return NULL;

    }

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

// CPop3MtmUi::CopyFromL()

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

//

CMsvOperation* CPop3MtmUi::CopyFromL(

    const CMsvEntrySelection& /*aSelection*/,

    TMsvId /*aTargetId*/,

    TRequestStatus& /*aStatus*/ )

    {

    IMUM_CONTEXT( CPop3MtmUi::CopyFromL, 0, KImumMtmLog );

    IMUM_IN();

    User::Leave( KErrNotSupported );

    IMUM_OUT();

    return NULL;

    }