/*

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

*       Static functions for imum

*

*/

// INCLUDE FILES

#include <bldvariant.hrh>

#include <miutset.h>

#include <s32file.h>

#include <eikenv.h>

#include <eikrutil.h>

#include <eikbtgpc.h>

#include <iapprefs.h>

#include <StringLoader.h>

#include <aknnotewrappers.h>

#include <AknGlobalNote.h>

#include <sendui.h>

#include <ErrorUI.h>                    // CErrorUI

#include <AknQueryDialog.h>

#include <aknnotedialog.h>

#include <StringLoader.h>

#include <MuiuOperationWait.h>          // CMuiuOperationWait

#include <MuiuMsvUiServiceUtilities.h>  // MsvUiServiceUtilities

#include <imapset.h>

#include <pop3set.h>

#include <smtpset.h>

#include <MTMStore.h>                   // CMtmStore

#include <mtmuibas.h>                   // BaseMtmUi

#include <messaginginternalcrkeys.h>    // Messaging keys

#include <centralrepository.h>          // CRepository

#include <CoreApplicationUIsSDKCRKeys.h>

#include <cemailaccounts.h>

#include <bldvariant.hrh>

#include <messagingvariant.hrh>

#include <MNcnInternalNotification.h>

#include <data_caging_path_literals.hrh>    // KDC_MTM_RESOURCE_DIR

#include <ImumUtils.rsg>

#include <bautils.h>

#include <muiuemailtools.h>

#include "ImumInMailboxUtilitiesImpl.h"

#include "ImumInMailboxServicesImpl.h"

#include "SenduiMtmUids.h"

#include "ImumMboxManager.h"

#include "ImumMboxData.h"

#include "EmailFeatureUtils.h"

#include "EmailUtils.H"

#include "ImumUtilsLogging.h"

#include "ImumPanic.h"

#include <ImumUtils.rsg>

#include "ImumMboxSettingsCtrl.h"

#include "ImumUtilsLogging.h"

#include "IMSSettingsNoteUi.h"

#include "ImumInternalApiImpl.h"

#include "ImumDaSettingsKeys.h"

#include "ImumInSettingsData.h"             // CImumInSettingsData

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KBytesInKiloByte = 1024;

const TInt KImumSizeBufferSize = 32;

const TInt KImumReplaceCharacterCount = 2;

const TInt KIMSMaxAoMailboxes = 2;

const TInt KImumExtraStringLength = 4;

_LIT( KImumDefaultNameFormat, "%S(%02d)" );

_LIT(KEmailUtilsComma, ",");

_LIT(KEmailUtilsSpace, " ");

_LIT( KIMSDirAndResFileName,"z:ImumUtils.rsc" );

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================ MEMBER FUNCTIONS ===============================

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

// MsvEmailMtmUiUtils::CheckAvailableDiskSpaceForDownloadL

// This is static function

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

//

EXPORT_C TBool MsvEmailMtmUiUtils::CheckAvailableDiskSpaceForDownloadL(

    TInt aMsgSize,

    CEikonEnv& aEikonEnv,

    CMsvSession& aSession )

//

// Check there is enough disk space on the specified drive to fetch a message

// of aMsgSize bytes. If not, display a message and return EFalse.

// static

    {

    IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::CheckAvailableDiskSpaceForDownloadL, 0, utils, KLogUi );

    if ( MsvUiServiceUtilities::DiskSpaceBelowCriticalLevelL(

        aSession, aMsgSize ) )

        {

        CErrorUI* errorUi = CErrorUI::NewLC( aEikonEnv );

        errorUi->ShowGlobalErrorNoteL( KErrDiskFull );

        CleanupStack::PopAndDestroy( errorUi );

        return EFalse;

        }

    return ETrue;

    }

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

// MsvEmailMtmUiUtils::CheckActiveAOLimitsL()

//

// This function goes through all the mailboxes and checks, if there are any

// Always Online enabled boxes around. The included mailbox id is ignored

// during the search. If less than 2 ( <2 ) always online mailboxes are found,

// ETrue is returned, otherwise EFalse is returned.

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

//

TBool MsvEmailMtmUiUtils::CheckActiveAOLimitsL(

    CImumInternalApi& aEmailApi,    

    const TMsvId aMailboxId )

    {

    IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::CheckActiveAOLimitsL, 0, utils, KLogUi );

    // Get the list of healthy mailboxes from the API

    TInt count = 0;    

    const MImumInHealthServices& healthApi = aEmailApi.HealthServicesL();

    MImumInHealthServices::RMailboxIdArray mailboxes;

    // Get the list of mailboxes in array. Gather the list based on the smtpId, 

    // since the aMailboxId is actually also the smtpId

    if ( healthApi.GetMailboxList( mailboxes, 

    		MImumInHealthServices::EFlagIncludeSmtp | 

    		MImumInHealthServices::EFlagGetHealthy ) == KErrNone )

    	{

    	for ( TInt mbox = mailboxes.Count(); --mbox >= 0; )

    		{           

            if ( aMailboxId != mailboxes[mbox] )

                {

                // Create object for the extended mail settings

                CImumInSettingsData* settings = 

                    aEmailApi.MailboxServicesL().LoadMailboxSettingsL( 

                        mailboxes[mbox] );

                CleanupStack::PushL( settings );

                TInt aoState = 0;

                if ( settings )

                	{

	                settings->GetAttr(

	                    TImumDaSettings::EKeyAutoRetrieval, aoState );

					// If always online is on, increase the count

					if ( aoState != TImumDaSettings::EValueAutoOff )

						{

						count++;

						}

                	}

                CleanupStack::PopAndDestroy( settings );

                settings = NULL;                         

                }                

            }

        }

    mailboxes.Reset();

    return count < KIMSMaxAoMailboxes;

    }

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

// MsvEmailMtmUiUtils::DoCEntryCopyMoveL

// This is static function

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

//

EXPORT_C CMsvOperation* MsvEmailMtmUiUtils::DoCEntryCopyMoveL(

    CMsvEntry& aEntry, const CMsvEntrySelection& aSel, TMsvId aTargetId, 

    TRequestStatus& aCompletionStatus, TBool aCopy)

    {

    IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::DoCEntryCopyMoveL, 0, utils, KLogUi );

    CMsvOperation* op = NULL;

    if(aCopy)

        {

        op = aEntry.CopyL(aSel, aTargetId, aCompletionStatus);

        }

    else

        {

        op = aEntry.MoveL(aSel, aTargetId, aCompletionStatus);

        }

    return op;

    }

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

// MsvEmailMtmUiUtils::StripCompleteEntriesLC

// This is static function

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

//

EXPORT_C CMsvEntrySelection* MsvEmailMtmUiUtils::StripCompleteEntriesLC(

    const CMsvEntry& aParent, const CMsvEntrySelection& aSelection)

    {

    IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::StripCompleteEntriesLC, 0, utils, KLogUi );

    CMsvEntrySelection* entries=aSelection.CopyLC();

    TInt cc = entries->Count();

    TMsvEntry tEntry;

    while(cc--)

        {

        tEntry = aParent.ChildDataL((*entries)[cc]);

        TMsvEmailEntry eEntry( tEntry );

        TBool complete = tEntry.Complete();

        TBool partial = eEntry.PartialDownloaded();

        if( complete && !partial )

            {

            entries->Delete(cc);

            }

        }

    return entries;

    }

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

// MsvEmailMtmUiUtils::StripDeletedEntriesLC

// This is static function

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

//

EXPORT_C CMsvEntrySelection* MsvEmailMtmUiUtils::StripDeletedEntriesLC(

    const CMsvEntry& aParent, const CMsvEntrySelection& aSelection)

    {

    IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::StripDeletedEntriesLC, 0, utils, KLogUi );

     // static

    CMsvEntrySelection* entries=aSelection.CopyLC();

    TInt cc = entries->Count();

    while(cc--)

        {

        const TMsvEmailEntry mailEntry(aParent.ChildDataL((*entries)[cc]));

        if(EDisconnectedDeleteOperation == mailEntry.DisconnectedOperation())

            {

            entries->Delete(cc);

            }

        }

    return entries;

    }

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

// MsvEmailMtmUiUtils::SetMessageInfoDataLCCCCC

// This is static function

// sets fields in the message info data array using TMsvEntry and CImHeader

// information; the TDes parameters are needed so that the strings have

// persisted memory to live in since the info data elements are all TPtrs

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

//

EXPORT_C void MsvEmailMtmUiUtils::SetMessageInfoDataLCCCCC(

    TMsgInfoMessageInfoData& aInfoData,

    CBaseMtm& aMtm,

    CCoeEnv& aEnv,

    TDes& /* aDateBuf */,

    TDes& /* aTimeBuf */,

    TDes& aSizeBuf,

    TDes& aPriorityBuf )

    {

    IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::SetMessageInfoDataLCCCCC, 0, utils, KLogUi );

    //retrieve header

    CMsvStore* store = aMtm.Entry().ReadStoreL();

    CleanupStack::PushL( store );

    CImHeader* header = CImHeader::NewLC();

    header->RestoreL( *store );

    //subject

    HBufC* tmpSubj = header->Subject().AllocLC();

    aInfoData.iSubject.Set( *tmpSubj );

    //date and time

    TMsvEntry tentry = aMtm.Entry().Entry();

    aInfoData.iDateTime = tentry.iDate;

    //size

    TInt size = tentry.iSize / KBytesInKiloByte; //in bytes

    if ( tentry.iSize % KBytesInKiloByte )

        {

        size++;

        }

    TBuf<KImumSizeBufferSize> kB;

    StringLoader::Load( kB, R_IMAS_MESSAGE_INFO_KB, &aEnv );

    StringLoader::Format( aSizeBuf, kB, -1, size );

    aInfoData.iSize.Set( aSizeBuf );

    //Priority

    MsvEmailMtmUiUtils::GetPriorityString(tentry,aEnv,aPriorityBuf );             

    aInfoData.iPriority.Set( aPriorityBuf );  

    //to field

    HBufC* toList = TurnArrayIntoCommaSeparatedStringLC(

        header->ToRecipients() );

    aInfoData.iTo.Set( *toList );

    //cc field

    HBufC* ccList = TurnArrayIntoCommaSeparatedStringLC(

        header->CcRecipients() );

    aInfoData.iCC.Set( *ccList );

    //bcc field

    HBufC* bccList = TurnArrayIntoCommaSeparatedStringLC(

        header->BccRecipients() );

    aInfoData.iBCC.Set( *bccList );

    //from field

    HBufC* tmpFrom = header->From().AllocLC();

    aInfoData.iFrom.Set( *tmpFrom );

    //take HBufCs out

    CleanupStack::Pop( 5 ); // CSI: 47 # tmpFrom, bccList, ccList, toList, tmpSubj.

    //destroy store and header. if not, message info in outbox prevents

    //mail sending!

    CleanupStack::PopAndDestroy( 2 ); // CSI: 47 # header, store.

    //put HBufCs back, so no need to change function name.

    CleanupStack::PushL( tmpSubj );

    CleanupStack::PushL( toList );

    CleanupStack::PushL( ccList );

    CleanupStack::PushL( bccList );

    CleanupStack::PushL( tmpFrom );

    }

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

// MsvEmailMtmUiUtils::SetMessageInfoDataLCC

// This is static function

// sets fields in the message info data array using TMsvEntry and CImHeader

// information; the TDes parameters are needed so that the strings have

// persisted memory to live in since the info data elements are all TPtrs

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

//

EXPORT_C TBool MsvEmailMtmUiUtils::SetMessageInfoDataLCC(

    TMsgInfoMessageInfoData& aInfoData,

    CBaseMtm& aMtm,

    CCoeEnv& aEnv,

    TDes& /* aDateBuf */,

    TDes& /* aTimeBuf */,

    TDes& aSizeBuf,

    TDes& aPriorityBuf )

    {

    IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::SetMessageInfoDataLCC, 0, utils, KLogUi );

    //retrieve header

    CMsvStore* store = NULL;

    CImHeader* header = NULL;

    TRAPD( storeError, store = aMtm.Entry().ReadStoreL() );

    if ( storeError == KErrNone )

        {

        CleanupStack::PushL( store );

        header = CImHeader::NewLC();

        TRAP( storeError, header->RestoreL( *store ) );

        // if restore leaves then we can find out lots of info from

        // TMsvEntry's fields.

        if ( storeError != KErrNone )

            {

            CleanupStack::PopAndDestroy( 2, store ); // CSI: 47 # header, store.

            header = NULL;

            store = NULL;

            }

        // if no errors, then store and header should be left to cleanup stack.

        }

    TMsvEntry tentry = aMtm.Entry().Entry();

    //subject

    if ( header )

        {

        aInfoData.iSubject.Set( header->Subject() );

        }

    else

        {

        aInfoData.iSubject.Set( tentry.iDescription );

        }

    //date and time

    aInfoData.iDateTime = tentry.iDate;

    //size

    TInt size = tentry.iSize / KBytesInKiloByte; //in bytes

    if ( tentry.iSize % KBytesInKiloByte )

        {

        size++;

        }

    TBuf<KImumSizeBufferSize> kB;

    StringLoader::Load( kB, R_IMAS_MESSAGE_INFO_KB, &aEnv );

    StringLoader::Format( aSizeBuf, kB, -1, size );

    aInfoData.iSize.Set( aSizeBuf );

     //Priority

     MsvEmailMtmUiUtils::GetPriorityString(tentry,aEnv,aPriorityBuf );             

    aInfoData.iPriority.Set( aPriorityBuf );  

    if ( header )

        {

        //to field

        HBufC* toList = TurnArrayIntoCommaSeparatedStringLC(

            header->ToRecipients() );

        aInfoData.iTo.Set( *toList );

        //cc field

        HBufC* ccList = TurnArrayIntoCommaSeparatedStringLC(

            header->CcRecipients() );

        aInfoData.iCC.Set( *ccList );

        //from field

        aInfoData.iFrom.Set( header->From() );

        }

    else

        {

        // to field

        HBufC* toList = HBufC::NewLC( 0 );

        aInfoData.iTo.Set( *toList );

        // cc field

        HBufC* ccList = HBufC::NewLC( 0 );

        aInfoData.iCC.Set( *ccList );

        // from field

        aInfoData.iFrom.Set( tentry.iDetails );

        }

    return ( header != NULL );

    }

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

// MsvEmailMtmUiUtils::TurnArrayIntoCommaSeparatedStringLC

// This is static function

// returns an HBufC* which contains all of the lines in aTextArray concaternated

// together with commas separating them

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

//

HBufC* MsvEmailMtmUiUtils::TurnArrayIntoCommaSeparatedStringLC(CDesCArray& aTextArray)

    {

    IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::TurnArrayIntoCommaSeparatedStringLC, 0, utils, KLogUi );

    TInt totalLength=0;

    //first calculate the length of string required

    TInt index = 0;

    for(index=0;index<aTextArray.Count();index++)

        {

        totalLength += aTextArray[index].Length();

        //don't count comma and space for last item

        if(index != ( aTextArray.Count() - 1 ) )

            {

            totalLength+=2; // CSI: 47 # comma and space.

            }

        }

    HBufC* list = HBufC::NewLC(totalLength);

    //now fill out the string

    for(index=0;index<aTextArray.Count();index++)

        {

        list->Des().Append(aTextArray[index]);

        //don't add for last item

        if(index != ( aTextArray.Count() - 1 ) )

            {

            list->Des().Append(KEmailUtilsComma);

            list->Des().Append(KEmailUtilsSpace);

            }

        }

    return list;

    }

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

// MsvEmailMtmUiUtils::ReplaceCharacters

// This is static function

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

//

void MsvEmailMtmUiUtils::ReplaceCharacters( TDes& aText )

    {

    IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::ReplaceCharacters, 0, utils, KLogUi );

    TBuf<KImumReplaceCharacterCount> replaceChars;

    replaceChars.Zero();

    replaceChars.Append( CEditableText::EParagraphDelimiter );

    replaceChars.Append( CEditableText::ETabCharacter );

    AknTextUtils::ReplaceCharacters(

        aText,

        replaceChars,

        CEditableText::ESpace );

    }

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

// MsvEmailMtmUiUtils::StripCharacters

// This is static function

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

//

void MsvEmailMtmUiUtils::StripCharacters( TDes& aText )

    {

    IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::StripCharacters, 0, utils, KLogUi );

    TBuf<KImumReplaceCharacterCount> stripChars;

    stripChars.Zero();

    stripChars.Append( CEditableText::EParagraphDelimiter );

    stripChars.Append( CEditableText::ETabCharacter );

    AknTextUtils::StripCharacters(

        aText,

        stripChars );

    }

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

// DisconnectMailboxL

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

//

EXPORT_C TBool MsvEmailMtmUiUtils::DisconnectMailboxL(

    const TMsvEntry& aService, CMsvSession& aSession )

    {

    IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::DisconnectMailboxL, 0, utils, KLogUi );

    __ASSERT_DEBUG( aService.iMtm != KSenduiMtmSmtpUid,

        User::Panic( KImumMtmUiPanic, EPanicRcvServiceMustBePOP3OrIMAP4) );

    if ( CIMSSettingsNoteUi::ShowQueryL(