/*

* Copyright (c) 2002 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:  

*     Item array for the message items to be displayed by mce.

*     Main view items are kept in memory (CArrayFixFlat<TMceListItem>) when created but

*     Message view list items are fetched from the msgs when needed in MdcaPoint function

*

*/

// INCLUDE FILES

#include <AknUtils.h>       // AknTextUtils

#include <mtudcbas.h>

#include <msvids.h>

#include <NpdApi.h>         // CNotepadApi

#include "MtmRegistryObserver.h" // MMtmUiDataRegistryObserver

#include <StringLoader.h>   // StringLoader

#include <mce.rsg>

#include <SenduiMtmUids.h>  // mtm uids

#include <eikenv.h>

#include "MceMessageListItemArray.h"

#include "MceBitmapResolver.h"

#include "MceIds.h" // KMceDocumentsEntryIdValue

#include "McePanic.h"

#include "MceCommands.hrh"

#include "MceLogText.h"

#include <MTMStore.h>

#include <commonphoneparser.h>

#include <aknappui.h>

#include <akncontext.h>

#include <aknconsts.h>

#include <e32math.h>

#include <bldvariant.hrh>

#include <featmgr.h>

#include <NumberGrouping.h>

#include <mmsconst.h>

#include <mmsgenutils.h>

#include <mmsclient.h>

#include <mtclreg.h>

#include <muiu.mbg>

#include <mtudreg.h>        // CMtmUiDataRegistry

// security data caging

#include <data_caging_path_literals.hrh>

#include <miutset.h>

#include <msvapi.h>

#include <ImumInternalApi.h>            // CImumInternalApi

#include <ImumInSettingsData.h>         // CImumInSettingsData

#include <muiuflags.h>

//FS email stuff

#include <centralrepository.h>

#include <MessagingDomainCRKeys.h>

const TInt KMceListArrayGranuality = 4;

// CONSTANTS

const TInt KMceArabicSemiColon                = {0x061B};

const TInt KMceSemiColon                      = {0x003B};

const TInt KMceMaxFormatFactor                = 2;

const TText KMceRLM = 0x200F;

const TText KMcePDF = 0x202C;

const TUid KUidMsvMessageListSortOrder={0x10005359};

_LIT( KSortSubjectSkipString, "*:*" );

const TChar KWhiteSpaceCharacter(' ');

const TInt KSortSubjectStringLength = 100;

// LOCAL CONSTANTS AND MACROS

enum

    {

    KMceListArrayDocAmount = 0x0,

    KMceListArrayDocAmountMany,

    KMceListArrayDocAmountTemp,

    KMceListArrayDocAmountTemps,

    KMceListArrayTimeFormatBuffer,

    KMceListArrayDateFormatBuffer

    };

//cmail update

#define KUidMsgTypeFsMtmVal               0x2001F406

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

// C++ default constructor can NOT contain any code that

// might leave.

//

CMceMessageListItemArray::CMceMessageListItemArray(

    CMsvSessionPtr aSession,

    TMsvId aFolderId,

    TMceListType aListType,

    CMceBitmapResolver& aBitmapResolver ) :

//    CArrayFixFlat<TMceListItem>( KMceListGranuality ),

    iSession( aSession ),

    iFolderId( aFolderId ),

    iListType( aListType ),

    iBitmapResolver( aBitmapResolver ),

    iEmailClientIntegration(EFalse),

    iEmailFramework(EFalse),

    iIntegratedEmailAppExcist(EFalse)

    {

    iDescriptionLength = iBitmapResolver.DescriptionLength();

    }

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

// CMceMessageListItemArray::ConstructL

// Symbian OS default constructor can leave.

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

void CMceMessageListItemArray::ConstructL()

    {

    CRepository* repository = NULL;

    // read phone number grouping feature flag

    iNumberGroupingEnabledFlag = MceUtils::NumberGroupingEnabled();

    iPreviousSelectionOrdering = TMsvSelectionOrdering(

            KMsvGroupByStandardFolders, EMsvSortByDateReverse);

    // Added for FS Email stuff

    FeatureManager::InitializeLibL();

    if ( FeatureManager::FeatureSupported( KFeatureIdFfEmailFramework ) )

        {

        iEmailFramework = ETrue;

        }

    if ( FeatureManager::FeatureSupported( KFeatureIdEmailMceIntegration) )

        {

        iEmailClientIntegration = ETrue;

        // Check if there is other than platform email application registered to handle S60 mailboxes   

        repository = NULL;

        TInt mtmPluginID = 0;

        TRAPD( ret, repository = CRepository::NewL(

               KCRUidSelectableDefaultEmailSettings ) );

        if ( ret == KErrNone )

            {

            TInt err = repository->Get( KIntegratedEmailAppMtmPluginId ,

                                        mtmPluginID );

            if ( err != KErrNone )

                {

                mtmPluginID = 0;

                }

            }

        delete repository;

        if ( mtmPluginID != 0 )

            {

            iIntegratedEmailAppExcist = ETrue;

            }

        }

    FeatureManager::UnInitializeLib();

    iFolderEntry = CMsvEntry::NewL(

        *iSession,

        iFolderId,

        iPreviousSelectionOrdering );

    iNumberOfMessagesStrings = new(ELeave)CDesCArrayFlat( KMceListGranuality );

    TBuf<KMcePrintableTextLength> tempString;

    CCoeEnv* eikonEnv = CEikonEnv::Static();

    StringLoader::Load( tempString, R_MCE_DOC_AMOUNT, eikonEnv );

    iNumberOfMessagesStrings->AppendL( tempString );

    StringLoader::Load( tempString, R_MCE_DOC_AMOUNT_MANY, eikonEnv );

    iNumberOfMessagesStrings->AppendL( tempString );

    StringLoader::Load( tempString, R_MCE_DOC_AMOUNT_TEMP, eikonEnv );

    iNumberOfMessagesStrings->AppendL( tempString );

    StringLoader::Load( tempString, R_MCE_DOC_AMOUNT_TEMPS, eikonEnv );

    iNumberOfMessagesStrings->AppendL( tempString );

    HBufC* timeFormat = eikonEnv->

        AllocReadResourceLC( R_QTN_TIME_USUAL_WITH_ZERO );

    iNumberOfMessagesStrings->AppendL( *timeFormat );

    CleanupStack::PopAndDestroy();

    HBufC* dateFormat = eikonEnv->

        AllocReadResourceLC( R_QTN_DATE_WITHOUT_YEAR_WITH_ZERO );

    iNumberOfMessagesStrings->AppendL( *dateFormat );

    CleanupStack::PopAndDestroy();

    // TODO

    iListBoxText = HBufC::NewL( iDescriptionLength*3 ); 

    iUiRegistry = CMtmUiDataRegistry::NewL(*iSession); 

    //FS Email stuff

    iMsgIndex = new ( ELeave )CArrayFixFlat<TInt>( KMceListArrayGranuality );

    }

// Two-phased constructor.

CMceMessageListItemArray* CMceMessageListItemArray::NewL(

    CMsvSessionPtr aSession,

    TMsvId aFolderId,

    TMceListType aListType,

    CMceBitmapResolver& aBitmapResolver )

    {

    CMceMessageListItemArray* self = new (ELeave) CMceMessageListItemArray(

        aSession, aFolderId, aListType, aBitmapResolver );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self

    return self;

    }

// Destructor

CMceMessageListItemArray::~CMceMessageListItemArray( )

    {

    delete iFolderEntry;

    delete iListBoxText;

    delete iNumberOfMessagesStrings;

    delete iUiRegistry;

    }

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

// CMceMessageListItemArray::ItemIndex

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

TInt CMceMessageListItemArray::ItemIndex(TMsvId aItemId) const

    {

    TInt foundItem = KErrNotFound;

    TInt count = iFolderEntry->Count();

    if ( (iEmailClientIntegration && iIntegratedEmailAppExcist) || iEmailFramework ) 

        {

        TRAPD( err, count = CreateEntryIndexL() );

        }

    for( TInt loop = 0; loop < count && foundItem == KErrNotFound ; loop++)

        {

        if ( (*iFolderEntry)[ GetEntryIndex( loop ) ].Id() == aItemId )

            {

            foundItem = loop;

            }

        }

    return foundItem;

    }

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

// CMceMessageListItemArray::ItemId

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

TMsvId CMceMessageListItemArray::ItemId( TInt aIndex ) const

    {

    TMsvId id = KErrNotFound;

    if ( aIndex >= 0 && iFolderEntry->Count() > aIndex )

        {

        id = (*iFolderEntry)[ GetEntryIndex( aIndex ) ].Id();

        }

    return id;

    }

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

// CMceMessageListItemArray::Item

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

const TMceListItem CMceMessageListItemArray::Item( TInt aIndex ) const

    {

    TMceListItem tempItem;

    tempItem.iMsvId = (*iFolderEntry)[ aIndex ].Id();

    tempItem.iExtraItem = EFalse;

    return tempItem;

    }

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

// CMceMessageListItemArray::GetEntry

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

TInt CMceMessageListItemArray::GetEntry( TMsvId aEntryId, TMsvEntry& aEntry )

    {

    TMsvId serviceId;

    return iSession->GetEntry( aEntryId, serviceId, aEntry );

    }

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

// CMceMessageListItemArray::SetFolderL

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

void CMceMessageListItemArray::SetFolderL( TMsvId aFolderId )

    {

    // this can only happen when iListType == EMceListTypeMessage

    iFolderEntry->SetEntryL( aFolderId );

    iFolderId = aFolderId;

    }

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

// CMceMessageListItemArray::IsItemFolder

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

TBool CMceMessageListItemArray::IsItemFolder( TMsvId aItemId ) const

    {

    TBool isFolder = EFalse;

    TMsvId serviceId;

    TMsvEntry entry;

    if ( iSession->GetEntry( aItemId, serviceId, entry ) == KErrNone &&

         entry.iType == KUidMsvFolderEntry )

        {

        isFolder = ETrue;

        }

    return isFolder;

    }

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

// CMceMessageListItemArray::MdcaCount

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

TInt CMceMessageListItemArray::MdcaCount() const

    {

    TInt retval=iFolderEntry->Count();

    if (( iEmailClientIntegration && iIntegratedEmailAppExcist )||(iEmailFramework))

        {

        if( iFolderId == KMsvDraftEntryId || 

                iFolderId == KMsvSentEntryId || 

                iFolderId == KMsvDeletedEntryFolderEntryId || 

                iFolderId == KMsvGlobalInBoxIndexEntryId || iFolderId == KMsvGlobalOutBoxIndexEntryId)

            {

            TRAPD( err, retval = CreateEntryIndexL() );

            }

        }   

    return ( retval );

    }

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

// CMceMessageListItemArray::MdcaPoint

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

TPtrC CMceMessageListItemArray::MdcaPoint( TInt aIndex ) const

    {

    return MakeStringForMessageView( aIndex );

    }

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

// CMceMessageListItemArray::MakeStringForMessageView

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

TPtrC CMceMessageListItemArray::MakeStringForMessageView( TInt aIndex ) const

    {

    __ASSERT_DEBUG( iListType == EMceListTypeMessage, Panic(EMceListItemArrayNotMessageViewList ) );

    const TMsvEntry* child;

    child = &(*iFolderEntry)[ GetEntryIndex( aIndex ) ];

    TPtr tempText = iListBoxText->Des();

    tempText.Zero();

    const TInt index = iBitmapResolver.BitmapIndex( *child );

    tempText.AppendNum( index );

    tempText.Append( KColumnListSeparator );

    if ( child->iType == KUidMsvFolderEntry )

        {

        AppendFolderString( tempText, *child );

        }

    else // should be KUidMsvMessageEntryValue

        {

        AppendMessageString( tempText, *child );

        }

    return tempText;

    }

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

// CMceMessageListItemArray::AppendMessageString

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

void CMceMessageListItemArray::AppendMessageString( TDes& aBuffer, const TMsvEntry& aEntry ) const

    {

    __ASSERT_DEBUG( aEntry.iType == KUidMsvMessageEntry, Panic(EMceListItemArrayEntryNotMessage ) );

    if ( aEntry.iMtm == KSenduiMtmImap4Uid || aEntry.iMtm == KSenduiMtmPop3Uid

        || aEntry.iMtm == KSenduiMtmSmtpUid )

        {

        StripAndAppendString( aBuffer, aEntry.iDetails );

        }

    else

        {

        TRAPD( error, AppendRecipientStringL( aBuffer, aEntry ) );

        if ( error != KErrNone )

            {

            // leave is not needed to handle; if leaves, nothing is shown

            }        

        }   

    aBuffer.Append( KColumnListSeparator );

    if ( ( iFolderEntry->Entry().Id() == KMsvGlobalInBoxIndexEntryId ) &&

        ( aEntry.iMtm == KUidMsgMMSNotification ) ) 

        {

        TRAP_IGNORE( MakeInboxStatusStringL( aBuffer, aEntry ) );

        }

    else if ( iFolderEntry->Entry().Id() == KMsvGlobalOutBoxIndexEntryId )

        {

        // in outbox show status of the message

        TRAP_IGNORE(MakeSendStatusStringL(aBuffer, aEntry));

        }

    else

        {

        TRAP_IGNORE( AppendTimeStringL( aBuffer, aEntry ) );

        if ( aEntry.iMtm==KSenduiMtmIrUid || aEntry.iMtm==KSenduiMtmBtUid )

            {

            TRAP_IGNORE( AppendBtIrMessageStringL( aBuffer, aEntry ) );

            }

         else

            {

            StripAndAppendString( aBuffer, aEntry.iDescription );

            }

        }

    aBuffer.Append( KColumnListSeparator );

    if ( aEntry.iMtm != KSenduiMtmMmsUid &&

         aEntry.Attachment() )

        {

        aBuffer.AppendNum( (TInt) EMceBitmapIndexAttachment );

	    aBuffer.Append( KColumnListSeparator );

        }

    TMsvPriority priority = aEntry.Priority();

    if ( priority == EMsvHighPriority )

        {

        aBuffer.AppendNum( EMceBitmapIndexPriorityHigh );

        aBuffer.Append( KColumnListSeparator );

        }

    else if ( priority == EMsvLowPriority )

        {

        aBuffer.AppendNum( EMceBitmapIndexPriorityLow );

        aBuffer.Append( KColumnListSeparator );

        }

    }

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

// CMceMessageListItemArray::AppendFolderString

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

void CMceMessageListItemArray::AppendFolderString( TDes& aBuffer, const TMsvEntry& aEntry ) const

    {

    __ASSERT_DEBUG( aEntry.iType == KUidMsvFolderEntry, Panic(EMceListItemArrayEntryNotFolder ) );

    StripAndAppendString( aBuffer, aEntry.iDetails );

    aBuffer.Append( KColumnListSeparator );

    if ( aEntry.Id() == KMceTemplatesEntryId )

        {        

        TInt templatesCount = CNotepadApi::NumberOfTemplates();

        templatesCount = templatesCount < 0 ? 0 : templatesCount;

        if ( templatesCount == 1 )

            {

            TBuf<KMcePrintableTextLength> tempString;

            tempString.Append( (*iNumberOfMessagesStrings)[

                KMceListArrayDocAmountTemp] );

            AknTextUtils::LanguageSpecificNumberConversion( tempString );         

            aBuffer.Append( tempString );

            }

        else

            {

            TBuf<KMcePrintableTextLength> tempString;

            StringLoader::Format( tempString,

                (*iNumberOfMessagesStrings)[KMceListArrayDocAmountTemps],

                -1, // no index in the key string

                templatesCount );

            AknTextUtils::LanguageSpecificNumberConversion( tempString );

            aBuffer.Append( tempString );

            }

        }

    else

        {

        TRAP_IGNORE( HandleFolderMessagesStringL( aBuffer, aEntry ) );        

        }

    aBuffer.Append( KColumnListSeparator );

    }

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

// CMceMessageListItemArray::HandleSessionEventL

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

void CMceMessageListItemArray::HandleSessionEventL(

    TMsvSessionEvent aEvent, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)

    {

    // TODO: why?

    switch (aEvent)

        {

    case EMsvEntriesCreated:

    case EMsvEntriesChanged:

    case EMsvEntriesDeleted:

    case EMsvMediaChanged:

    case EMsvMediaUnavailable:

    case EMsvMediaAvailable:

    case EMsvCloseSession:        

        break;

    default:

        break;

        }

    }

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

// CMceMessageListItemArray::SetRegistryObserver

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

void CMceMessageListItemArray::SetRegistryObserver( MMtmUiDataRegistryObserver* aRegistryObserver )

    {

    iRegistryObserver = aRegistryObserver;

    }

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

// CMceMessageListItemArray::MakeSendStatusStringL

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

void CMceMessageListItemArray::MakeSendStatusStringL(TDes& aText, const TMsvEntry& aEntry) const

    {

    if ( iRegistryObserver )

        {

        CBaseMtmUiData* data=iRegistryObserver->GetMtmUiDataL(aEntry.iMtm);

        if ( data )

            {

            HBufC* statusText=data->StatusTextL(aEntry);

            if ( statusText->Length() )

                {

                aText.Append( statusText->Des() );

                }

            else

                {

                aText.Append( CEditableText::ESpace );