/*

* Copyright (c) 2007 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: This file implements class CIpsPlgMsgMapper.

*

*/

#include "emailtrace.h"

#include "ipsplgheaders.h"

_LIT( KMimeTypeTextPlain, "text/plain" );

_LIT( KMimeTypeTextHtml, "text/html" );

_LIT( KMimeTypeTextRtf, "text/rtf" );

_LIT( KSlash, "/" );

_LIT( KCharSemicolon, ";" );

_LIT( KCharEquals, "=" );

_LIT( KCharsetTag, "CHARSET" );

_LIT( KMessageExtension, ".eml" );

// Supported multipart content types

_LIT( KMimeTypeMultipartRelated, "multipart/related" );

_LIT( KMimeTypeMultipartMixed, "multipart/mixed" );

_LIT( KMimeTypeMultipartAlternative, "multipart/alternative" );

_LIT( KMimeTypeMultipartDigest, "multipart/digest" );

_LIT( KMimeTypeMultipartRfc822, "message/rfc822" );

_LIT( KMimeTypeMultipartPartial, "message/partial" );

_LIT( KMimeTypeMultipartDirectory, "text/directory" );

_LIT( KMimeTypeMultipartExternalBody, "message/external-body" );

_LIT( KMimeTypeMultipartParallel, "multipart/parallel" );

const TInt KCharEscape       = 0x5C;

const TInt KCharNonPrintable = 0x1F;

const TInt KCharAt           = 0x40;

const TInt KMaxContentTypeLength = 200;

const TInt KEmbeddedMsgExtensionLength  = 4;

// ======== CONSTRUCTORS & DESTRUCTOR ========

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

// CIpsPlgMsgMapper::NewL()

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

//

CIpsPlgMsgMapper* CIpsPlgMsgMapper::NewL(

    CMsvSession& aSession,

    CIpsPlgSosBasePlugin& aPlugin )

    {

    FUNC_LOG;

    CIpsPlgMsgMapper* self = CIpsPlgMsgMapper::NewLC( aSession, aPlugin );

    CleanupStack::Pop( self );

    return self;

    }

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

// CIpsPlgMsgMapper::NewLC()

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

//

CIpsPlgMsgMapper* CIpsPlgMsgMapper::NewLC(

    CMsvSession& aSession,

    CIpsPlgSosBasePlugin& aPlugin )

    {

    FUNC_LOG;

    CIpsPlgMsgMapper* self =

        new( ELeave ) CIpsPlgMsgMapper( aSession, aPlugin );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CIpsPlgMsgMapper::~CIpsPlgMsgMapper()

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

//

CIpsPlgMsgMapper::~CIpsPlgMsgMapper()

    {

    FUNC_LOG;

    }

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

// CIpsPlgMsgMapper::CIpsPlgMsgMapper()

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

//

CIpsPlgMsgMapper::CIpsPlgMsgMapper(

    CMsvSession& aSession,

    CIpsPlgSosBasePlugin& aPlugin )

    : iSession( aSession ), iPlugin( aPlugin )

    {

    FUNC_LOG;

    }

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

// CIpsPlgMsgMapper::ConstructL()

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

//

void CIpsPlgMsgMapper::ConstructL()

    {

    FUNC_LOG;

    }

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

// CIpsPlgMsgMapper::GetMailMessageL()

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

//

CFSMailMessage* CIpsPlgMsgMapper::GetMailMessageL(

    CMsvEntry& aEntry )

    {

    FUNC_LOG;

    TFSMailMsgId msgId( iPlugin.PluginId(), aEntry.Entry().Id() );

    CFSMailMessage* fsMsg = CFSMailMessage::NewLC( msgId );

    fsMsg->SetFolderId(

        TFSMailMsgId( iPlugin.PluginId(), aEntry.Entry().Parent() ) );

    CMsvStore* store( NULL );

    if ( aEntry.HasStoreL() )

        {

        store = aEntry.ReadStoreL();

        CleanupStack::PushL( store );

        }

    SetEnvelopeL( &aEntry, store, *fsMsg );

    // Apparently, this should be done only with

    // EFSMsgDataStructure, but EFSMsgDataEnvelope is currently

    // used by assuming that it reads also the content-type of

    // the message

    SetStructureL( &aEntry, *fsMsg );

    TMsvEmailEntry tEntry( aEntry.Entry() );

    SetFlags( tEntry, *fsMsg );

    if ( store )

        {

        CleanupStack::PopAndDestroy( store );

        }

    CleanupStack::Pop( fsMsg );

    return fsMsg;

    }

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

// CIpsPlgMsgMapper::GetMailMessageL()

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

//

CFSMailMessage* CIpsPlgMsgMapper::GetMailMessageL(

    const TFSMailMsgId& aMailboxId,

    const TMsvEmailEntry& aEntry,

    const TFSMailDetails& aDetails )

    {

    FUNC_LOG;

    TFSMailMsgId msgId( iPlugin.PluginId(), aEntry.Id() );

    CFSMailMessage* result = CFSMailMessage::NewLC( msgId );

    result->SetMailBoxId( aMailboxId );

    result->SetFolderId(

        TFSMailMsgId( iPlugin.PluginId(), aEntry.Parent() ) );

    SetFlags( aEntry, *result );

    SetFetchStateL( aEntry, aEntry.Id(), EFalse, *result );

    switch( aDetails )

        {

        case EFSMsgDataDate:

            SetDateL( aEntry, *result );

            break;

        case EFSMsgDataSubject:

            SetSubjectL( aEntry, *result );

            break;

        case EFSMsgDataSender:

            SetSenderL( aEntry.iDetails, *result );

            break;

        case EFSMsgDataEnvelope:

        case EFSMsgDataStructure:

            {

            CMsvStore* store( NULL );

            CMsvEntry* cEntry = iSession.GetEntryL( aEntry.Id() );

            CleanupStack::PushL( cEntry );

            if ( cEntry && cEntry->HasStoreL() )

                {

                store = cEntry->ReadStoreL();

                CleanupStack::PushL( store );

                }

            SetEnvelopeL( cEntry, store, *result );

            // Apparently, this should be done only with

            // EFSMsgDataStructure, but EFSMsgDataEnvelope is currently

            // used by assuming that it reads also the content-type of

            // the message

            SetStructureL( cEntry, *result );

            if ( store )

                {

                CleanupStack::PopAndDestroy( store );

                }

            CleanupStack::PopAndDestroy( cEntry );

            break;

            }

        case EFSMsgDataIdOnly:

        default:

            break;

        }

    CleanupStack::Pop( result );

    return result;

    }

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

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

void CIpsPlgMsgMapper::GetChildPartsL(

    const TFSMailMsgId& aMailBoxId,

    const TFSMailMsgId& aMessageId,

    const TFSMailMsgId& aParentId,

    RPointerArray<CFSMailMessagePart>& aParts )

    {

    FUNC_LOG;

    if ( aParentId.IsNullId() )

        // the caller wants the children of the message

        {

        GetChildPartsOfMessageEntryL( aMailBoxId, aMessageId, aParts );

        }

    else

        // the caller wants the parts of the 'real' subpart

        {

        GetChildPartsOfFolderEntryL( aMailBoxId, aMessageId, aParentId.Id(),

            aParts );

        }

    }

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

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

CFSMailMessagePart* CIpsPlgMsgMapper::GetMessagePartL(

    TMsvId aEntryId,

    const TFSMailMsgId& aMailBoxId,

    const TFSMailMsgId& aMessageId )

    {

    FUNC_LOG;

    CFSMailMessagePart* result( NULL );

    TInt status;

    TMsvId serviceId;

    TMsvEmailEntry tEntry;

    status = iSession.GetEntry( aEntryId, serviceId, tEntry );

    if ( status == KErrNone )

        {

        switch ( tEntry.iType.iUid )

            {

            case KUidMsvFolderEntryValue:

                {

                result = ConvertFolderEntry2MessagePartL( tEntry,

                    aMailBoxId, aMessageId );

                break;

                }

            case KUidMsvAttachmentEntryValue:

            case KUidMsvMessageEntryValue:

                {

                result = ConvertAttachmentEntry2MessagePartL( tEntry,

                    aMailBoxId, aMessageId );

                break;

                }

            case KUidMsvEmailTextEntryValue:

            case KUidMsvEmailHtmlEntryValue:

            case KUidMsvEmailExternalBodyEntryValue:

            case KUidMsvEmailRtfEntryValue:

                {

                result = ConvertBodyEntry2MessagePartL( tEntry, aMailBoxId,

                    aMessageId );

                break;

                }

            }

        }

    return result;

    }

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

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

TBool CIpsPlgMsgMapper::ChangeTEntryFlagsL(

    TMsvEmailEntry& aEmlEntry,

    const CFSMailMessage& aMessage )

    {

    FUNC_LOG;

    TInt msgFlags = aMessage.GetFlags();

    TBool modified ( EFalse );

    TBool unread( aEmlEntry.Unread() );

    if ( !LogicalXor( unread, msgFlags & EFSMsgFlag_Read ) )

        {

        aEmlEntry.SetUnread( !unread );

        modified = ETrue;

        }

    // EFSMsgFlag_Low

    // EFSMsgFlag_Important

    TMsvPriority msgPriority;

    if ( msgFlags & EFSMsgFlag_Important )

        {

        msgPriority = EMsvHighPriority;

        }

    else if ( msgFlags & EFSMsgFlag_Low )

        {

        msgPriority = EMsvLowPriority;

        }

    else

        {

        msgPriority = EMsvMediumPriority;

        }

    if ( aEmlEntry.Priority() != msgPriority )

        {

        aEmlEntry.SetPriority( msgPriority );

        modified = ETrue;

        }

    // EFSMsgFlag_FollowUpComplete: no counterpart in Symbian message

    // EFSMsgFlag_FollowUp: supported only with IMAP4 (see below)

    // EFSMsgFlag_Attachments: It does not seem reasonable to update

    // this flag here (but when attachments are added)

    // EFSMsgFlag_Multiple: no counterpart in Symbian message

    // EFSMsgFlag_CalendarMsg

    if( ( aEmlEntry.iMtm == KSenduiMtmSmtpUid ) && ( msgFlags & EFSMsgFlag_CalendarMsg ) )

        {

        if( !aEmlEntry.ICalendar() )

            {

            aEmlEntry.SetICalendar( ETrue );

            modified = ETrue;

            }

        }

    // EFSMsgFlag_Answered: supported only with IMAP4 (see below)

    // EFSMsgFlag_Forwarded: no counterpart in Symbian message in S60 3.1

    // EFSMsgFlag_OnlyToMe: no counterpart in Symbian message

    // EFSMsgFlag_RemoteDeleted: no counterpart in Symbian message

    // EFSMsgFlag_HasMsgSender: no counterpart in Symbian message

    //this applies to POP too. Just ignore the misleading naming

    // moved to fix EANA-7HUD2G, pop doesn't support permanent flags

    // EFSMsgFlag_Answered

    // IMAP flags

    if ( aEmlEntry.iMtm == KSenduiMtmImap4Uid )

        {

            // EFSMsgFlag_FollowUp

        if ( LogicalXor( aEmlEntry.FlaggedIMAP4Flag(),

                         ( msgFlags & EFSMsgFlag_FollowUp ) ) )

            {

            aEmlEntry.SetFlaggedIMAP4Flag( !aEmlEntry.FlaggedIMAP4Flag() );

            modified = ETrue;

            }

        // EFSMsgFlag_Answered

        if ( LogicalXor( aEmlEntry.AnsweredIMAP4Flag(),

                         ( msgFlags & EFSMsgFlag_Answered ) ) )

            {

            aEmlEntry.SetAnsweredIMAP4Flag( !aEmlEntry.AnsweredIMAP4Flag() );

            modified = ETrue;

            }

        }

    return modified;

    }

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

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

void CIpsPlgMsgMapper::UpdateMessageFlagsL(

    TMsvId aEntryId,

    const CFSMailMessage& aMessage )

    {

    FUNC_LOG;

    // This function updates tEntry from aMessage

    CMsvEntry* cEntry = iSession.GetEntryL( aEntryId );

    CleanupStack::PushL( cEntry );

    TMsvEmailEntry tEntry( cEntry->Entry() );

    TBool isModified = ChangeTEntryFlagsL( tEntry, aMessage );

    if ( isModified )

        {

        CIpsPlgOperationWait* waiter = CIpsPlgOperationWait::NewLC();

        CMsvOperation* ops = cEntry->ChangeL( tEntry, waiter->iStatus );

        CleanupStack::PushL( ops );

        waiter->Start();

        CleanupStack::PopAndDestroy( 2, waiter );

        }

    CleanupStack::PopAndDestroy( cEntry );

    }

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

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

CMsvOperation* CIpsPlgMsgMapper::UpdateMessageFlagsAsyncL(

    TMsvId aEntryId,

    const CFSMailMessage& aMessage,

    TRequestStatus& aStatus )

    {

    FUNC_LOG;

    // This function updates tEntry from aMessage

    CMsvEntry* cEntry = iSession.GetEntryL( aEntryId );

    CleanupStack::PushL( cEntry );

    TMsvEmailEntry tEntry( cEntry->Entry() );

    TBool isModified = ChangeTEntryFlagsL( tEntry, aMessage );

    CMsvOperation* ops = NULL;

    if ( isModified )

        {

        ops = cEntry->ChangeL( tEntry, aStatus );

        }

    CleanupStack::PopAndDestroy( cEntry );

    return ops;

    }

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

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

void CIpsPlgMsgMapper::SetFSMessageFlagsL(

    const TMsvEmailEntry& aEntry, CFSMailMessage& aMsg )

    {

    FUNC_LOG;

    // this is just stupid through call, but now not need to

    // move SetFlags to public

    SetFlags( aEntry, aMsg );

    }

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

// CIpsPlgMsgMapper::NewChildPartL

// The method supports currently only the multipart/alternative structure

// construction (which is needed in the meeting request messages).

// The creation of the multipart structure happens by changing the folder

// type of the (SMTP) message entry itself. The folder entry is created

// by Symbian MTM later when new parts are added below the multipart

// structure. This causes some problems because there is no new entry

// in this phase and so the new CFSMailMessagePart instance do not

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

CFSMailMessagePart* CIpsPlgMsgMapper::NewChildPartL(

    const TFSMailMsgId& /* aMailBoxId */,

    const TFSMailMsgId& aMessageId,

    const TFSMailMsgId& /* aParentPartId */,

    const TDesC& /*aContentType*/ )

    {

    FUNC_LOG;

    CFSMailMessagePart* result( NULL );

    result = CFSMailMessagePart::NewLC( aMessageId,

                TFSMailMsgId( aMessageId.PluginId().iUid,

                    KMsvNullIndexEntryIdValue ) );

    CleanupStack::Pop( result );

    return result;

    }

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

// CIpsPlgMsgMapper::SetDateL

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

//

void CIpsPlgMsgMapper::SetDateL(

    const TMsvEntry& aEntry,

    CFSMailMessage& aMsg )

    {

    FUNC_LOG;

    const TTime date =  aEntry.iDate;

    aMsg.SetDate( date );

    }

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

// CIpsPlgMsgMapper::SetSubjectL

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

//

void CIpsPlgMsgMapper::SetSubjectL(

    const TMsvEntry& aEntry,

    CFSMailMessage& aMsg )

    {

    FUNC_LOG;

    aMsg.SetSubject( aEntry.iDescription );

    }

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

// CIpsPlgMsgMapper::SetSenderL

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

//

void CIpsPlgMsgMapper::SetSenderL(

    TPtrC aSender,

    CFSMailMessage& aMsg )

    {

    FUNC_LOG;

    CFSMailAddress* addr = CFSMailAddress::NewLC();

    ConvertAddressL( aSender, *addr );

    aMsg.SetSender( addr );

    CleanupStack::Pop( addr );

    }

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

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

void CIpsPlgMsgMapper::SetEnvelopeL(

    const CMsvEntry* aEntry,

    CMsvStore* aStore,

    CFSMailMessage& aMsg )

    {

    FUNC_LOG;

    CFSMailAddress* addr = NULL;

    TMsvEmailEntry tEntry( aEntry->Entry() );

    SetDateL( tEntry, aMsg );

    SetSubjectL( tEntry, aMsg );