/*

* 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 "CFSMailBox.h"

#include "CFSMailRequestObserver.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;

	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;

	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;

	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;

    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;

	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;

		folderIds.Reset();

		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 );

		folderIds.Reset();

		}

	}

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

// 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);

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

		{

		syncState = plugin->CurrentSyncState( GetId() );

		}

	return syncState;

	}

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

// CFSMailBox::HasCapability

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

EXPORT_C TBool CFSMailBox::HasCapability( const TFSMailBoxCapabilities aCapability ) const

{

    FUNC_LOG;

	TBool capability = EFalse;

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

		{

		TRAPD( err,capability = plugin->MailboxHasCapabilityL( aCapability,GetId() )) ;

		if ( err != KErrNone )

			{

			capability = EFalse;

			}

		}

	return capability;

}

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

// CFSMailBox::GetMailBoxStatus

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

EXPORT_C TFSMailBoxStatus CFSMailBox::GetMailBoxStatus()

{

    FUNC_LOG;

	TFSMailBoxStatus status(EFSMailBoxOffline);

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

	{

		status = plugin->GetMailBoxStatus( GetId() );

	}

	return status;

}

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

// CFSMailBox::SetCredentialsL

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

EXPORT_C void CFSMailBox::SetCredentialsL( const TDesC& aUsername, const TDesC& aPassword )