/*

* 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:  common mailbox object

*

*/

#include "emailtrace.h"

#include <bamdesca.h>

#include "cfsmailplugin.h"

#include "cmrcalendarinfoimpl.h"

#include "emailextensionuids.hrh"

#include "cfsmailbox.h"

#include "cfsmailrequestobserver.h"

#include "cmailboxstateext.h"

const TInt KMaxMruEntries( 150 );

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

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

// CFSMailBox::NewLC

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

EXPORT_C CFSMailBox* CFSMailBox::NewLC(TFSMailMsgId aMailBoxId)

{

    FUNC_LOG;

  CFSMailBox* api = new (ELeave) CFSMailBox();

  CleanupStack:: PushL(api);

  api->ConstructL(aMailBoxId);

  return api;

} 

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

// CFSMailBox::NewL

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

EXPORT_C CFSMailBox* CFSMailBox::NewL(TFSMailMsgId aMailBoxId)

{

    FUNC_LOG;

  CFSMailBox* api =  CFSMailBox::NewLC(aMailBoxId);

  CleanupStack:: Pop(api);

  return api;

}

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

// CFSMailBox::CFSMailBox

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

CFSMailBox::CFSMailBox()

{

    FUNC_LOG;

    // get requesthandler pointer

    iRequestHandler = static_cast<CFSMailRequestHandler*>(Dll::Tls());

}

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

// CFSMailBox::~CFSMailBox

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

EXPORT_C CFSMailBox::~CFSMailBox()

{

    FUNC_LOG;

    // extension KMailboxExtMrCalInfo needs to be released here because of

    // MR UI

    CEmailExtension* extension = NULL;

    TRAPD( err, extension = CExtendableEmail::ExtensionL( KMailboxExtMrCalInfo ) );

    if( extension != NULL && err==KErrNone )

        {

        // Release extension needs to be called twice because, previous

        // CExtendableEmail::ExtensionL( KMailboxExtMrCalInfo ) call increased

        // reference counter with one, so there is need to relase this one also.

        CExtendableEmail::ReleaseExtension( extension );

        }

    iFolders.ResetAndDestroy();

}

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

// CFSMailBox::ConstructL

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

void CFSMailBox::ConstructL(TFSMailMsgId aMailBoxId)

{

    FUNC_LOG;

    // <cmail>

    const TFSMailMsgId myId = aMailBoxId;

    CFSMailBoxBase::ConstructL(myId);   

    iMailBoxId = aMailBoxId; 

    // </cmail>    

}

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

// CFSMailBox::GoOnlineL

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

EXPORT_C void CFSMailBox::GoOnlineL()

    {

    FUNC_LOG;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        plugin->GoOnlineL( GetId() );

        }

    }

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

// CFSMailBox::GoOfflineL

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

EXPORT_C void CFSMailBox::GoOfflineL()

    {

    FUNC_LOG;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        plugin->GoOfflineL( GetId() );

        }

    }

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

// CFSMailBox::CancelSyncL

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

EXPORT_C void CFSMailBox::CancelSyncL()

    {

    FUNC_LOG;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        plugin->CancelSyncL( GetId() );

        }

    }

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

// CFSMailBox::GetLastSyncStatusL

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

EXPORT_C TFSProgress CFSMailBox::GetLastSyncStatusL()

    {

    FUNC_LOG;

    TFSProgress progress;

    progress.iError = EFalse;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        progress = plugin->GetLastSyncStatusL( GetId() );       

        }

    return progress;

    }

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

// CFSMailBox::RefreshNowL

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

EXPORT_C TInt CFSMailBox::RefreshNowL(

    MFSMailRequestObserver& aOperationObserver )

    {

    FUNC_LOG;

    TFSPendingRequest request;

    request.iRequestId = 0;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        // init asynchronous request

        request = iRequestHandler->InitAsyncRequestL( GetId().PluginId(),

                                                        aOperationObserver );

        MFSMailRequestObserver* observer = request.iObserver;

        TRAPD(err,plugin->RefreshNowL( GetId(), *observer, request.iRequestId));

        if(err != KErrNone)

            {

            iRequestHandler->CompleteRequest(request.iRequestId);

            User::Leave(err);

            }

        }

    return request.iRequestId;

   }

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

// CFSMailBox::RefreshNowL

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

EXPORT_C TInt CFSMailBox::RefreshNowL( )

    {

    FUNC_LOG;

    TFSPendingRequest request;

    request.iRequestId = 0;

    MFSMailRequestObserver* observer = NULL;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        // init asynchronous request

        request = iRequestHandler->InitAsyncRequestL( GetId().PluginId(), *observer );

        observer = request.iObserver;

        TRAPD(err,plugin->RefreshNowL( GetId(), *observer, request.iRequestId));

        if(err != KErrNone)

            {

            iRequestHandler->CompleteRequest(request.iRequestId);

            User::Leave(err);

            }

        }

    return request.iRequestId;

   }

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

// CFSMailBox::CreateMessageToSend

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

EXPORT_C CFSMailMessage* CFSMailBox::CreateMessageToSend( )

{

    FUNC_LOG;

    CFSMailMessage* message = NULL;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        TRAPD(err,message = plugin->CreateMessageToSendL( GetId() ));

        if(err != KErrNone)

            {

            message = NULL;

            }

        }

    return message;

}

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

// CFSMailBox::CreateForwardMessage

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

EXPORT_C CFSMailMessage* CFSMailBox::CreateForwardMessage(  TFSMailMsgId aOriginalMessageId,

                                                            const TDesC& aHeaderDescriptor )

{

    FUNC_LOG;

    CFSMailMessage* message = NULL;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        TRAPD(err,message = plugin->CreateForwardMessageL( GetId(), 

                                                                aOriginalMessageId,

                                                                aHeaderDescriptor ));

        if(err != KErrNone)

            {

            message = NULL;

            }

        }

    return message;

}

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

// CFSMailBox::CreateReplyMessage

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

EXPORT_C CFSMailMessage* CFSMailBox::CreateReplyMessage( TFSMailMsgId aOriginalMessageId,

                                                         TBool aReplyToAll,

                                                         const TDesC& aHeaderDescriptor )

{

    FUNC_LOG;

    CFSMailMessage* message = NULL;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        TRAPD(err,message = plugin->CreateReplyMessageL( GetId(),

                                                            aOriginalMessageId,

                                                            aReplyToAll,

                                                            aHeaderDescriptor ));

        if(err != KErrNone)

            {

            message = NULL;

            }

        }

    return message;

}

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

// CFSMailBox::GetStandardFolderId

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

EXPORT_C TFSMailMsgId CFSMailBox::GetStandardFolderId(TFSFolderType aFolderType)

{

    FUNC_LOG;

    TFSMailMsgId folderId;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        TRAPD(err, folderId = plugin->GetStandardFolderIdL(GetId(), aFolderType ));

        if(err != KErrNone)

            {

            folderId.SetNullId();

            }

        }

    return folderId;

}

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

// CFSMailBox::SendMessageL

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

EXPORT_C void CFSMailBox::SendMessageL( CFSMailMessage& aMessage )

    {

    FUNC_LOG;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        UpdateMrusL( aMessage.GetToRecipients(),

                     aMessage.GetCCRecipients(),

                     aMessage.GetBCCRecipients() );

        plugin->SendMessageL( aMessage );

        }

    }

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

// CFSMailBox::ListFolders

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

EXPORT_C void CFSMailBox::ListFolders(  TFSMailMsgId aFolder,

                                        RPointerArray<CFSMailFolder>& aFolderList)

{

    FUNC_LOG;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

    {

        TRAPD(err, plugin->ListFoldersL(GetId(),aFolder,aFolderList));

        if(err != KErrNone)

            {

            aFolderList.ResetAndDestroy();

            }

    }

}

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

// CFSMailBox::ListFolders

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

EXPORT_C RPointerArray<CFSMailFolder>& CFSMailBox::ListFolders( )

{   

    iFolders.ResetAndDestroy();

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

    {

        TRAPD(err,plugin->ListFoldersL(GetId(),iFolders));

        if(err != KErrNone)

            {

            iFolders.ResetAndDestroy();

            }

    }

    return iFolders;

}

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

// CFSMailBox::GetBrandingIdL

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

EXPORT_C TDesC& CFSMailBox::GetBrandingIdL( )

{

    FUNC_LOG;

    return BrandingId();

}

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

// CFSMailBox::MoveMessagesL

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

EXPORT_C void CFSMailBox::MoveMessagesL( const RArray<TFSMailMsgId>& aMessageIds, 

                                         const TFSMailMsgId aSourceFolderId, 

                                         const TFSMailMsgId aDestinationFolderId )

{

    FUNC_LOG;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        plugin->MoveMessagesL(GetId(), aMessageIds, aSourceFolderId, aDestinationFolderId);

        }

}

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

// CFSMailBox::MoveMessagesL

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

EXPORT_C TInt CFSMailBox::MoveMessagesL( MFSMailRequestObserver& aOperationObserver,

                                         const RArray<TFSMailMsgId>& aMessageIds, 

                                         const TFSMailMsgId aSourceFolderId, 

                                         const TFSMailMsgId aDestinationFolderId )

{

    FUNC_LOG;

    TFSPendingRequest request;

    request.iRequestId = 0;

    if( CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid( GetId() ) )

        {

        // init asynchronous request

        request = iRequestHandler->InitAsyncRequestL( GetId().PluginId(),

                                                        aOperationObserver );        

        plugin->MoveMessagesL(

            GetId(), 

            aMessageIds, 

            aSourceFolderId, 

            aDestinationFolderId, 

            aOperationObserver, 

            request.iRequestId );

        }

    return request.iRequestId;

}

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

// CFSMailBox::CopyMessagesL

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

EXPORT_C void CFSMailBox::CopyMessagesL( const RArray<TFSMailMsgId>& aMessageIds, 

                                         RArray<TFSMailMsgId>& aNewMessages, 

                                         const TFSMailMsgId aSourceFolderId, 

                                         const TFSMailMsgId aDestinationFolderId )

{

    FUNC_LOG;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        plugin->CopyMessagesL(GetId(), aMessageIds, aNewMessages,

                                aSourceFolderId, aDestinationFolderId );    

        }

}

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

// CFSMailBox::SearchL

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

EXPORT_C void CFSMailBox::SearchL( const RPointerArray<TDesC>& /*aSearchStrings*/,

                                   const TFSMailSortCriteria&  /*aSortCriteria*/,

                                   MFSMailBoxSearchObserver&   /*aSearchObserver*/,

                                   const RArray<TFSMailMsgId>  /*aFolderIds */ )

    {

    FUNC_LOG;

    }

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

// CFSMailBox::SearchL

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

EXPORT_C void CFSMailBox::SearchL( const RPointerArray<TDesC>& aSearchStrings,

                                   const TFSMailSortCriteria& aSortCriteria,

                                   MFSMailBoxSearchObserver& aSearchObserver )

    {

    FUNC_LOG;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        // get mailbox folder list

        iFolders.ResetAndDestroy();

        plugin->ListFoldersL(GetId(),iFolders);

        TFSMailMsgId draftsFolderId = GetStandardFolderId( EFSDraftsFolder );

        TFSMailMsgId outboxId = GetStandardFolderId( EFSOutbox );

        // remove outbox, drafts folder from folder list

        RArray<TFSMailMsgId> folderIds;

        CleanupClosePushL( folderIds );  

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

        {

            TFSMailMsgId id = iFolders[i]->GetFolderId();

            if( id != draftsFolderId && id != outboxId )

            {

                folderIds.Append(id);

            }

        }

        // start search

        plugin->SearchL( GetId(), folderIds, aSearchStrings, aSortCriteria, aSearchObserver );

        CleanupStack::PopAndDestroy( &folderIds );

        }

    }

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

// CFSMailBox::CancelSearch

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

EXPORT_C void CFSMailBox::CancelSearch()

    {

    FUNC_LOG;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        plugin->CancelSearch( GetId() );

        }

    }

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

// CFSMailBox::ClearSearchResultCache

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

EXPORT_C void CFSMailBox::ClearSearchResultCache()

    {

    FUNC_LOG;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId()))

        {

        plugin->ClearSearchResultCache( GetId() );

        }

    }

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

// CFSMailBox::ListMrusL

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

EXPORT_C MDesCArray* CFSMailBox::ListMrusL() const

    {

    FUNC_LOG;

    MDesCArray* mruList(0);

    if ( CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetId() ) )

        {

        mruList = plugin->GetMrusL( GetId() );

        }

    return mruList;

    }

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

// CFSMailBox::CurrentSyncState

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

EXPORT_C TSSMailSyncState CFSMailBox::CurrentSyncState() const

    {

    FUNC_LOG;

    TSSMailSyncState syncState(Idle);