/*

* 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:   Email interface implementation, translator utilities.

*

*/

#include "baseplugincommonutils.h"

static void TranslateMsgStoreAttendeeL(

    CMsgStorePropertyContainer& aSrc,

    TUint aIdx,

    MMROrganizer& aAttendee );

static void TranslateMsgStoreAttendeesL(

    CMsgStorePropertyContainer& aMessage,

    CBaseMrInfoObject& aMrInfo,

    const TDesC8& aProperty,

    MMRAttendee::TAttendeeRole aRole );

/**@ the info object's description field is mapped to the message body which can be

of arbitrary size; at the moment cap the max description size to avoid memory problems.*/

const TInt KMaxDescription = 512*1024;

/**

 *

 */

class TDayOfWeekFtor

    {

    public:

        virtual void operator () ( MRRecurrenceRule::TMRRecurrentDay aDay ) = 0;

    };

/**

 *

 */

class TWeekDayTranslator : public TDayOfWeekFtor

    {

    public:

        TWeekDayTranslator( RArray<MRRecurrenceRule::TMRRecurrentDay>& aDays )

            : iDays( aDays )

            {

            };

        virtual void operator () ( MRRecurrenceRule::TMRRecurrentDay aDay )

            {

            iDays.AppendL( aDay );

            };

    private:

        RArray<MRRecurrenceRule::TMRRecurrentDay>& iDays;

    };

/**

 *

 */

class TMonthDayTranslator : public TDayOfWeekFtor

    {

    public:

        TMonthDayTranslator( MRRecurrenceRule::TMRRecurrentDay& aDayOfWeek )

            : iDayOfWeek( aDayOfWeek )

            {

            };

        virtual void operator () ( MRRecurrenceRule::TMRRecurrentDay aDay )

            {

            /**@ the contract with IMS/Outlook is that there is a single day

            set in a monthly by day of week rule; asserts ?*/

            iDayOfWeek = aDay;

            };

    private:

        MRRecurrenceRule::TMRRecurrentDay& iDayOfWeek;

    };

/**

 *

 */

EXPORT_C void CBasePlugin::TranslateMsgStorePropsL(

    const TFSMailMsgId& aMailBoxId,

    CMsgStorePropertyContainer& aMessage,

    CFSMailMessagePart& aFsMsg,

    const TFSMailDetails aDetails )

    {

    __LOG_ENTER( "TranslateMsgStorePropsL" )

    __LOG_WRITE_FORMAT1_INFO( "aDetails = 0x%X.", aDetails )

    TFSMailMsgId fsId( GetPluginId(), aMessage.ParentId() );

    aFsMsg.SetFolderId( fsId );

    TUint idx = 0;

    //subject.

    if ( ( EFSMsgDataEnvelope & aDetails || EFSMsgDataStructure & aDetails

        || EFSMsgDataSubject & aDetails )

        && aMessage.FindProperty( KMsgStorePropertySubject, idx ) )

        {

        const TDesC& subject = aMessage.PropertyValueDesL( idx );

        aFsMsg.SetSubject( subject );

        idx = 0;

        __LOG_WRITE_FORMAT1_INFO( "Subject: %S.", &subject );

        }

    //from.

    if ( ( EFSMsgDataEnvelope & aDetails|| EFSMsgDataStructure & aDetails

        || EFSMsgDataSender & aDetails )

        && aMessage.FindProperty( KMsgStorePropertyFrom, idx ) )

        {

        CFSMailAddress* address = FetchEmailAddressL( aMessage, idx );

        aFsMsg.SetSender( address );

        idx = 0;

        }

    //received.

    if ( ( EFSMsgDataEnvelope & aDetails || EFSMsgDataStructure & aDetails

        || EFSMsgDataDate & aDetails )

        && aMessage.FindProperty( KMsgStorePropertyReceivedAt, idx ) )

        {

        TTime time;

        aMessage.PropertyValueTimeL( idx, time );

        aFsMsg.SetDate( time );

        idx = 0;

        __LOG_WRITE8_FORMAT1_INFO( "Received: %ld.", time.Int64() );

        }

    //sent.

    if ( ( EFSMsgDataEnvelope & aDetails || EFSMsgDataStructure & aDetails

        || EFSMsgDataDate & aDetails )

        && aMessage.FindProperty( KMsgStorePropertySent, idx ) )

        {

        TTime time;

        aMessage.PropertyValueTimeL( idx, time );

        aFsMsg.SetDate( time );

        idx = 0;

        __LOG_WRITE8_FORMAT1_INFO( "Sent: %ld.", time.Int64() );

        }

    if ( EFSMsgDataEnvelope & aDetails || EFSMsgDataStructure & aDetails )

        {

        //to recipients.

        while ( aMessage.FindProperty( KMsgStorePropertyTo, idx, idx ) )

            {

            CFSMailAddress* address = FetchEmailAddressL( aMessage, idx );

            aFsMsg.AppendToRecipient( address );

            ++idx;

            }

        idx = 0;

        //cc recipients.

        while ( aMessage.FindProperty( KMsgStorePropertyCc, idx, idx ) )

            {

            CFSMailAddress* address = FetchEmailAddressL( aMessage, idx );

            aFsMsg.AppendCCRecipient( address );

            ++idx;

            }

        idx = 0;

        //bcc recipients.

        while ( aMessage.FindProperty( KMsgStorePropertyBcc, idx, idx ) )

            {

            CFSMailAddress* address = FetchEmailAddressL( aMessage, idx );

            aFsMsg.AppendBCCRecipient( address );

            ++idx;

            }

        idx = 0;

        //flags.

        if ( aMessage.FindProperty( KMsgStorePropertyFlags, idx ) )

            {

            TUint32 i = aMessage.PropertyValueUint32L( idx );

            aFsMsg.SetFlag( i );

            idx = 0;

            __LOG_WRITE_FORMAT1_INFO( "Flags: 0x%X.", i )

            }

        //content-size.

        if ( aMessage.FindProperty( KMsgStorePropertySize, idx ) )

            {

            TUint32 i = aMessage.PropertyValueUint32L( idx );

            aFsMsg.SetContentSize( i );

            idx = 0;

            __LOG_WRITE_FORMAT1_INFO( "Content-size: %d.", i )

            }

        //content-type.

        if ( aMessage.FindProperty( KMsgStorePropertyContentType, idx ) )

            {

            const TDesC& contentType = aMessage.PropertyValueDesL( idx );

            idx = 0;

            if ( aMessage.FindProperty( KMsgStorePropertyCharset, idx ) )

                {

                _LIT( KCharSemicolon, ";" );

                const TDesC& charSet = aMessage.PropertyValueDesL( idx );

                TInt maxLength = contentType.Length() + KFSMailContentTypeParamCharset().Length() +

                    KCharSemicolon().Length() + charSet.Length();

                HBufC* buf = HBufC::NewLC( maxLength );

                TPtr bufPtr( buf->Des() );

                bufPtr.Append( contentType );

                bufPtr.Append( KCharSemicolon );

                bufPtr.Append( KFSMailContentTypeParamCharset );

                bufPtr.Append( charSet );

                aFsMsg.SetContentType( bufPtr );

                __LOG_WRITE_FORMAT1_INFO( "Content-type: %S.", &bufPtr );

                CleanupStack::PopAndDestroy( buf );

                }

            else

                {

                aFsMsg.SetContentType( contentType );

                __LOG_WRITE_FORMAT1_INFO( "Content-type: %S.", &contentType );

                }

            idx = 0;

            }

        //content-id.

        if ( aMessage.FindProperty( KMsgStorePropertyContentId, idx ) )

            {

            const TDesC& contentId = aMessage.PropertyValueDesL( idx );

            aFsMsg.SetContentIDL( contentId );

            idx = 0;

            __LOG_WRITE_FORMAT1_INFO( "Content-id: %S.", &contentId );

            }

        //content-description.

        if ( aMessage.FindProperty( KMsgStorePropertyContentDescription, idx ) )

            {

            const TDesC& contentDescription = aMessage.PropertyValueDesL( idx );

            aFsMsg.SetContentDescription( contentDescription );

            idx = 0;

            __LOG_WRITE_FORMAT1_INFO(

                "Content-description: %S.", &contentDescription );

            }

        //content-class.

        if ( aMessage.FindProperty( KMsgStorePropertyContentClass, idx ) )

            {

            const TDesC& contentClass = aMessage.PropertyValueDesL( idx );

            aFsMsg.SetContentClass( contentClass );

            idx = 0;

            }

        //fetched content size.

        if ( aMessage.FindProperty( KMsgStorePropertyRetrievedSize, idx ) )

            {

            TUint32 retrievedSize = aMessage.PropertyValueUint32L( idx );

            aFsMsg.SetFetchedContentSize( retrievedSize );

            idx = 0;

            }

        //content-disposition.

        if ( aMessage.FindProperty( KMsgStorePropertyContentDisposition, idx ) )

            {

            const TDesC& contentDisposition = aMessage.PropertyValueDesL( idx );

            aFsMsg.SetContentDisposition( contentDisposition );

            idx = 0;

            __LOG_WRITE_FORMAT1_INFO(

                "Content-desposition: %S.", &contentDisposition );

            }

        //meeting request info.

        if ( aMessage.FindProperty( KMsgStorePropertyMeetingRequest, idx ) )

            {

            CMsgStorePropertyContainer* mrInfo

                = aMessage.PropertyValueContainerL( idx );

            CleanupStack::PushL( mrInfo );

            TranslateMsgStoreMrL( aMailBoxId, aMessage, *mrInfo, aFsMsg );

            CleanupStack::PopAndDestroy( mrInfo ); 

            idx = 0;

            }

        //read-only size

        if ( aMessage.FindProperty( KMsgStorePropertyReadOnlySize, idx ) )

            {

            TUint readOnlySize = aMessage.PropertyValueUint32L(idx);

            aFsMsg.SetReadOnlyPartSize(readOnlySize);

            idx = 0;

            }

        }

    __LOG_EXIT

    } //TranslateMsgStorePropsL.

/**

 * Common msgstore meeting request fields translation to Freestyle.

 *

 * @param aMessage

 * @param aFsMsg

 */

EXPORT_C void CBasePlugin::TranslateMsgStoreMrL(

    const TFSMailMsgId& aMailBoxId,

    CMsgStorePropertyContainer& aMessage,

    CMsgStorePropertyContainer& aCalendar,

    CFSMailMessagePart& aFsMsg )

    {

    __LOG_ENTER( "TranslateMsgStoreMrL" )

    CBaseMrInfoObject* mmrInfo = CBaseMrInfoObject::NewL();

    CleanupStack::PushL( mmrInfo );

    TUint idx;

    //uid.

    idx = 0;

    if ( aCalendar.FindProperty( KMsgStorePropertyMrGuid, idx ) )

        {

        const TDesC8& uid8 = aCalendar.PropertyValueDes8L( idx );

        HBufC* uid = HBufC::NewLC( uid8.Length() );

        //uid not utf8-encoded.

        uid->Des().Copy( uid8 );

        mmrInfo->SetUidL( uid );

        CleanupStack::Pop( uid );

        }

    //subject.

    idx = 0;

    if ( aMessage.FindProperty( KMsgStorePropertySubject, idx ) )

        {

        const TDesC& subject = aMessage.PropertyValueDesL( idx );

        mmrInfo->SetSubjectL( subject );

        __LOG_WRITE_FORMAT1_INFO( "MR Subject: %S.", &subject );

        }

    //description - the plain/text email body.

    __LOG_WRITE_INFO( "About to translate the description field." );

    idx = 0;

    TMsgStoreId msgId = aMessage.Id();

    CMailboxInfo& mailBox = GetMailboxInfoL( aMailBoxId.Id() );

    CMsgStoreMessage* theMessage = mailBox().FetchMessageL( msgId, KMsgStoreInvalidId );

    CleanupStack::PushL( theMessage );

    CMsgStoreMessagePart* plainText = GetBodyPartL( *theMessage );

    if ( NULL != plainText )

        {

        CleanupStack::PushL( plainText );

        TUint length = plainText->ContentLengthL();

        //the body can be of arbitrary size - taking precautions until resolved.

        length = length < KMaxDescription ? length : KMaxDescription;

        HBufC* description = HBufC::NewLC( length );

        RBuf8 buf8;

        CleanupClosePushL( buf8 );

        buf8.CreateL( length );

        plainText->FetchContentToBufferL( buf8 );

        //replace the cr with the lf per iCal spec otherwise the Symbian iCal importer would leave with -20;

        //see ANN0001 for more info.

        _LIT8( KCrLf, "\r\x00\n\x00" );

        _LIT8( KLf, "\n\x00" );

        const TUint crLfSize = KCrLf().Size();

        TInt idx = KErrNotFound;

        while ( KErrNotFound != ( idx = buf8.Find( KCrLf ) ) )

        	{

        	buf8.Replace( idx, crLfSize, KLf );

        	}

        TPtrC ptr( KNullDesC );

        ptr.Set( reinterpret_cast<const TUint16*>( buf8.Ptr() ), buf8.Length() / 2 );

        mmrInfo->SetDescriptionL( ptr );

        //CleanupStack::PopAndDestroy( body );

        CleanupStack::PopAndDestroy( &buf8 );

        CleanupStack::PopAndDestroy( description );

        CleanupStack::PopAndDestroy( plainText );

        }

    CleanupStack::PopAndDestroy( theMessage );

    //creation date.

    idx = 0;

    if ( aCalendar.FindProperty( KMsgStorePropertyMrCreationDate, idx ) )

        {

        TTime time;

        aCalendar.PropertyValueTimeL( idx, time );

        mmrInfo->SetCreationTimeInUtcL( time );

        }

    //start date.

    idx = 0;

    if ( aCalendar.FindProperty( KMsgStorePropertyMrStartDate, idx ) )

        {

        TTime time;

        aCalendar.PropertyValueTimeL( idx, time );

        mmrInfo->SetStartTimeInUtcL( time );

        }

    //end date.

    idx = 0;

    if ( aCalendar.FindProperty( KMsgStorePropertyMrEndDate, idx ) )

        {

        TTime time;

        aCalendar.PropertyValueTimeL( idx, time );

        mmrInfo->SetEndTimeInUtcL( time );

        }

    //location.

    idx = 0;

    if ( aCalendar.FindProperty( KMsgStorePropertyMrLocation, idx ) )

        {

        const TDesC& location = aCalendar.PropertyValueDesL( idx );

        mmrInfo->SetLocationL( location );

        }

    //organizer / from.

    idx = 0;

    if ( aMessage.FindProperty( KMsgStorePropertyFrom, idx ) )

        {

        TranslateMsgStoreAttendeeL( aMessage, idx, mmrInfo->MROrganizerL() );

        }

    //attendees / to.

    TranslateMsgStoreAttendeesL(

        aMessage, *mmrInfo, KMsgStorePropertyTo, MMRAttendee::EMRAttendeeParticipant );

    //attendees / cc.

    TranslateMsgStoreAttendeesL(

        aMessage, *mmrInfo, KMsgStorePropertyCc, MMRAttendee::EMRAttendeeOptionalParticipant );

    //recurrence info.

    __LOG_WRITE_INFO( "About to start translating the recurrence rule." )

    CBaseMrRecurrenceRule* recurrenceRule = CBaseMrRecurrenceRule::NewL();

    CleanupStack::PushL( recurrenceRule );

    //start date.

    /**@ dupes the infoobject one ?*/

    idx = 0;

    if ( aCalendar.FindProperty( KMsgStorePropertyMrStartDate, idx ) )

        {

        TTime time;

        aCalendar.PropertyValueTimeL( idx, time );

        recurrenceRule->SetRecurrenceStartTimeL( time );

        }

    //end date.

    idx = 0;

    if ( aCalendar.FindProperty( KMsgStorePropertyMrRecurEndDate, idx ) )

        {

        TTime time;

        aCalendar.PropertyValueTimeL( idx, time );

        recurrenceRule->SetRecurrenceUntilL( time );

        }

    //frequency.    

    idx = 0;

    if ( aCalendar.FindProperty( KMsgStorePropertyMrFrequency, idx ) )

        {

        TUint32 imsFreq = aCalendar.PropertyValueUint32L( idx );

        recurrenceRule->SetRecurrentInterval( imsFreq );

        }

    //priority.

    idx = 0;

    if ( aCalendar.FindProperty( KMsgStorePropertyMrPriority, idx ) )

        {

        TUint32 priority = aCalendar.PropertyValueUint32L( idx );

        mmrInfo->SetPriorityL( priority );

        }

    /**@ privacy/sensitivity missing ? */

    /*idx = 0;

    if ( aCalendar.FindProperty( KMsgStorePropertyMrPrivate, idx ) )

        {

        TBool private = aCalendar.PropertyValueBoolL( idx );

        }*/

    //method.

    idx = 0;

    if ( aCalendar.FindProperty( KMsgStorePropertyMrMethod, idx ) )

        {

        TUint32 method = aCalendar.PropertyValueUint32L( idx );

        mmrInfo->SetMethod( static_cast<MMRInfoObject::TMRMethod>( method ) );

        }

    //status.

    idx = 0;

    if ( aCalendar.FindProperty( KMsgStorePropertyMrStatus, idx ) )

        {

        TUint32 status = aCalendar.PropertyValueUint32L( idx );

        mmrInfo->SetMRResponseL( static_cast<MMRInfoObject::TResponse>( status ) );

        }

    //alarm/reminder time.

    idx = 0;

    if ( aCalendar.FindProperty( KMsgStorePropertyMrReminder, idx ) )

        {

        TBool hasReminder = aCalendar.PropertyValueBoolL( idx );

        if ( hasReminder )