/*

* Copyright (c) 2007-2009 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:  ESMR FS mailbox utilities implementation

*

*/

#include "cesmrfsmailboxutils.h"

#include "esmrhelper.h"

#include "esmrinternaluid.h"

#include "cfsmailclient.h"

#include "cfsmailbox.h"

#include "cmrcalendarinfo.h"

#include <calentry.h>

#include <caluser.h>

#include <ct/rcpointerarray.h>

#include "emailtrace.h"

// Unnamed namespace for local definitions

namespace {

// Definition for email address comparison

const TInt KEqualEmailAddress( 0 );

/**

 * Listes all FS mailboxes. On return aMailboxes contains FS mailboxes

 * @param aMailClient FS mail client

 * @aMailboxes Reference to mailboxes

 */

void ListMailBoxesL(

        CFSMailClient& aMailClient,

        RPointerArray<CFSMailBox>& aMailboxes )

    {

    TFSMailMsgId msgId;

    aMailClient.ListMailBoxes(

            msgId,

            aMailboxes );

    }

/**

 * Helper class for Email extension cleanup

 */

class TExtensionCleanup

    {

    public:

    TExtensionCleanup(

            CFSMailBox* aMailbox,

            CEmailExtension* aExtension )

        : iMailbox( aMailbox ),

          iExtension( aExtension )

        {

        }

    void Close()

        {

        iMailbox->ReleaseExtension( iExtension );

        }

    private:

        /// Not own: mailbox

        CFSMailBox* iMailbox;

        // Not own: mailbox extension

        CEmailExtension* iExtension;

    };

}

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

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

// CESMRFsMailboxUtils::CESMRFsMailboxUtils

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

//

inline CESMRFsMailboxUtils::CESMRFsMailboxUtils(

        CMRMailboxUtils& aMailboxUtils )

:   iMRMailboxUtils( aMailboxUtils )

    {

    FUNC_LOG;

    }

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

// CESMRFsMailboxUtils::~CESMRFsMailboxUtils

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

//

EXPORT_C CESMRFsMailboxUtils::~CESMRFsMailboxUtils()

    {

    FUNC_LOG;

    if ( iMailClient )

        {

        iMailClient->Close();

        }

    }

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

// CESMRFsMailboxUtils::NewL

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

//

EXPORT_C CESMRFsMailboxUtils* CESMRFsMailboxUtils::NewL(

            CMRMailboxUtils& aMailboxUtils )

    {

    FUNC_LOG;

    CESMRFsMailboxUtils* self =

            new (ELeave) CESMRFsMailboxUtils( aMailboxUtils );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRFsMailboxUtils::ConstructL

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

//

void CESMRFsMailboxUtils::ConstructL()

    {

    FUNC_LOG;

    // Do nothing

    }

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

// CESMRFsMailboxUtils::SetPhoneOwnerL

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

//

EXPORT_C TInt CESMRFsMailboxUtils::SetPhoneOwnerL(

            CCalEntry& aCalEntry,

            TMsvId aPrimaryBox )

    {

    FUNC_LOG;

    TInt err( iMRMailboxUtils.SetPhoneOwnerL( aCalEntry, aPrimaryBox ) );

    // Check that phone owner was set correctly

    if ( err == KErrNotFound )

        {

        // Check if phone owner can be set using FS mailboxes

        // Loop throug all mailboxes in this plug-in

        RCPointerArray<CFSMailBox> mailboxes;

        CleanupClosePushL( mailboxes );

        ListMailBoxesL(

                MailClientL(),

                mailboxes );

        TInt dummyIndex( -1 ); // don't care

        CCalUser* phoneOwner = PhoneOwnerL( aCalEntry, mailboxes, dummyIndex );

        if ( phoneOwner )

            {

            aCalEntry.SetPhoneOwnerL( phoneOwner );

            err = KErrNone;

            }

        CleanupStack::PopAndDestroy( &mailboxes );

        }

    return err;

    }

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

// CESMRFsMailboxUtils::SetPhoneOwnerL

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

//

EXPORT_C TInt CESMRFsMailboxUtils::SetPhoneOwnerL(

    CCalEntry& aCalEntry,

    CFSMailClient& aMailClient,

    CFSMailMessage& aMailMessage )

    {

    FUNC_LOG;

    TInt err( KErrNotFound );

    TFSMailMsgId mailboxId( aMailMessage.GetMailBoxId() );

    CFSMailBox* mailbox = aMailClient.GetMailBoxByUidL( mailboxId );

    if ( !mailbox )

        {

        return KErrNotFound;

        }

    CleanupStack::PushL( mailbox );

    TPtrC mailboxOwnerAddName(

            mailbox->OwnMailAddress().GetEmailAddress() );

    CCalUser* po = NULL;

    CCalUser* organizer = aCalEntry.OrganizerL();

    if ( organizer &&

         KEqualEmailAddress == organizer->Address().CompareF(mailboxOwnerAddName) )

        {

        po = organizer;

        }

    else

        {

        RPointerArray<CCalAttendee>& attendees = aCalEntry.AttendeesL();

        TInt attendeeCount( attendees.Count() );

        for( TInt i(0); i < attendeeCount && !po; ++i )

            {

            CCalAttendee* attendee = attendees[i];

            TPtrC attendeeAddr( attendee->Address() );

            if ( KEqualEmailAddress == attendeeAddr.CompareF(mailboxOwnerAddName) )

                {

                po = attendee;

                }

            }

        }

    if ( po )

        {

        aCalEntry.SetPhoneOwnerL( po );

        err = KErrNone;

        }

    CleanupStack::PopAndDestroy( mailbox );

    return err;

    }

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

// CESMRFsMailboxUtils::FSEmailPluginForEntryL

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

//

EXPORT_C TESMRMailPlugin CESMRFsMailboxUtils::FSEmailPluginForEntryL(

        const CCalEntry& aEntry )

    {

    FUNC_LOG;

    RCPointerArray<CFSMailBox> mailboxes;

    CleanupClosePushL( mailboxes );

    ListMailBoxesL(

            MailClientL(),

            mailboxes );

    CCalUser* phoneOwner = aEntry.PhoneOwnerL();

    TPtrC poMailAddress( phoneOwner->Address() );

    CFSMailBox* fsEmailMailbox = NULL;

    TInt mailboxCount( mailboxes.Count() );

    for (TInt j(0); j < mailboxCount && !fsEmailMailbox; ++j )

        {

        TPtrC mailboxOwnerAddName(

                mailboxes[j]->OwnMailAddress().GetEmailAddress() );

        if ( KEqualEmailAddress == mailboxOwnerAddName.CompareF(poMailAddress) )

            {

            // Correct mailbox is found

            fsEmailMailbox = mailboxes[j];

            }

        }

    TESMRMailPlugin plugin( EESMRUnknownPlugin );

    if ( fsEmailMailbox )

        {

        // Mailbox was found --> We need to resolve mailboxes plug-in

        TFSMailMsgId mailboxId( fsEmailMailbox->GetId( ) );

        TUid pluginId( mailboxId.PluginId() );

        if ( TUid::Uid( KEasFreestylePlugin ) == pluginId )

            {

            plugin = EESMRActiveSync;

            }

        else if ( TUid::Uid( KIntellisync ) == pluginId )

            {

            plugin = EESMRIntelliSync;

            }

        else if ( TUid::Uid( KFSEmailPop3 ) == pluginId ||

                TUid::Uid( KFSEmailImap4 ) == pluginId )

            {

            plugin = EESMRImapPop;

            }

        }

    CleanupStack::PopAndDestroy( &mailboxes );

    return plugin;

    }

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

// CESMRFsMailboxUtils::DefaultMailboxSupportCapabilityL

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

//

EXPORT_C TBool CESMRFsMailboxUtils::DefaultMailboxSupportCapabilityL(

        CESMRFsMailboxUtils::TMRMailboxCapability aCapability )

    {

    FUNC_LOG;

    TBool retValue( EFalse );

    CFSMailBox* defaultMailbox = DefaultMailboxL();

    CleanupStack::PushL( defaultMailbox );

    ASSERT( defaultMailbox );

    switch ( aCapability )

        {

        case CESMRFsMailboxUtils::EMRCapabilityAttachment:

            {

            retValue = defaultMailbox->HasCapability(

                            EFSMboxCapaSupportsAttahmentsInMR );

            }

            break;

        }

    CleanupStack::PopAndDestroy( defaultMailbox );

    return retValue;

    }

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

// CESMRFsMailboxUtils::GetCalendarDatabaseIdL

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

//

void CESMRFsMailboxUtils::GetCalendarDatabaseIdL(

            TESMRMailPlugin aPlugin,

            TCalFileId& aDbId )

    {

    FUNC_LOG;

    TUid pluginUid( TUid::Null() );

    aDbId = KNullFileId;

    switch ( aPlugin )

        {

        case EESMRActiveSync:

            {

            pluginUid = TUid::Uid( KEasFreestylePlugin );

            break;

            }

        case EESMRIntelliSync:

            {

            pluginUid = TUid::Uid( KIntellisync );

            break;

            }

        default:

            {

            break;

            }

        }

    if ( pluginUid != TUid::Null() )

        {

        RCPointerArray<CFSMailBox> mailboxes;

        CleanupClosePushL( mailboxes );

        ListMailBoxesL(

                MailClientL(),

                mailboxes );

        for ( TInt i = 0; i < mailboxes.Count(); ++i )

            {

            CFSMailBox* mailbox = mailboxes[ i ];

            if ( mailbox->GetId().PluginId() == pluginUid )

                {

                // Resolve database id using mailbox extension

                CEmailExtension* extension =

                        mailbox->ExtensionL( KMailboxExtMrCalInfo );

                TExtensionCleanup cleanup( mailbox, extension );

                CleanupClosePushL( cleanup );

                CMRCalendarInfo* calInfo =

                        static_cast< CMRCalendarInfo* >( extension );

                if ( calInfo )

                    {

                    calInfo->GetCalendarDatabaseIdL( aDbId );

                    }

                CleanupStack::PopAndDestroy( &cleanup ); // Release extension

                break;

                }

            }

        CleanupStack::PopAndDestroy( &mailboxes );

        }

    }

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

// CESMRFsMailboxUtils::PhoneOwnerL

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

//

CCalUser* CESMRFsMailboxUtils::PhoneOwnerL(

    const CCalEntry& aCalEntry,

    const RPointerArray<CFSMailBox>& aMailBoxes,

    TInt& aMatchIndex )

    {

    FUNC_LOG;

    aMatchIndex = -1; // no match yet

    // 1. test if phone owner is organizer:

    CCalUser* organizer = aCalEntry.OrganizerL(); // ownership not transf.

    if ( organizer )

        {

        if ( IsPhoneOwnerL( *organizer, aMailBoxes, aMatchIndex ) )

            {

            return organizer;

            }

        }

    // 2. test if phone owner is attendee:

    RPointerArray<CCalAttendee>& attendees = aCalEntry.AttendeesL();

    TInt attCount( attendees.Count() );

    for ( TInt i( 0 );i < attCount; ++i )

        {

        CCalUser* att = static_cast<CCalUser*>(attendees[i]);

        if ( IsPhoneOwnerL( *att, aMailBoxes, aMatchIndex ) )

            {

            return att;

            }

        }

    // Matching attendee was not found:

    return NULL;

    }

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

// CESMRFsMailboxUtils::IsPhoneOwnerL

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

//

TBool CESMRFsMailboxUtils::IsPhoneOwnerL(

    const CCalUser& aUser,

    const RPointerArray<CFSMailBox>& aMailBoxes,

    TInt& aMatchIndex )

    {

    FUNC_LOG;

    TPtrC addr = ESMRHelper::AddressWithoutMailtoPrefix( aUser.Address() );

    aMatchIndex = -1; // no match yet

    TInt boxCount( aMailBoxes.Count() );

    for ( TInt i( 0 ); i < boxCount; ++i )

        {

        TPtrC mailboxOwnerAddName(

                aMailBoxes[i]->OwnMailAddress().GetEmailAddress() );

        if ( addr.CompareF( mailboxOwnerAddName ) == KEqualEmailAddress )

            {

            // first match is enough:

            aMatchIndex = i;

            return ETrue;

            }

        }

    return EFalse; // no match

    }

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

// CESMRFsMailboxUtils::MailClientL

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

//

CFSMailClient& CESMRFsMailboxUtils::MailClientL()

    {

    FUNC_LOG;

    if ( !iMailClient )

        {

        iMailClient = CFSMailClient::NewL();

        }

    return *iMailClient;

    }

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

// CESMRFsMailboxUtils::DefaultMailboxL

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

//

CFSMailBox* CESMRFsMailboxUtils::DefaultMailboxL()

    {

    FUNC_LOG;

    CFSMailBox* defaultMailbox( NULL );

    CMRMailboxUtils::TMailboxInfo mailboxInfo;

    TInt err = iMRMailboxUtils.GetDefaultMRMailBoxL( mailboxInfo );

    if ( KErrNone == err )

        {

        RCPointerArray<CFSMailBox> mailboxes;

        CleanupClosePushL( mailboxes );

        ListMailBoxesL( MailClientL(), mailboxes );

        TInt mailboxCount( mailboxes.Count() );

        for (TInt j(0); j < mailboxCount && !defaultMailbox; ++j )

            {

            TPtrC mailboxOwnerAddName(

                    mailboxes[j]->OwnMailAddress().GetEmailAddress() );

            if ( KEqualEmailAddress ==

                 mailboxOwnerAddName.CompareF( mailboxInfo.iEmailAddress) )

                {

                // Default mailbox is found

                defaultMailbox = mailboxes[j];

                mailboxes.Remove( j );

                }

            }

        CleanupStack::PopAndDestroy( &mailboxes );

        }

    return defaultMailbox;

    }

// EOF