/*
* Copyright (c) 2008 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:  Data Store Adapter for MRU list
 *
*/



#include <CPsData.h>
#include <CPcsDefs.h>
#include <coemain.h>
#include <data_caging_path_literals.hrh>
#include <VPbkEng.rsg>
//<cmail>
#include "CFSMailClient.h"
#include "CPsMruAdapter.h"
//</cmail>
#include <mmf/common/mmfcontrollerpluginresolver.h> // CleanupResetAndDestroy


#define PRINT(x)

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

// Identifier for mailbox Uri
_LIT(KDefaultMailBoxURI, "mailbox://");
// Separator for plugin/mailbox identifiers inside the Uri string
const TText8 KDefaultMailBoxURISeparator = '/';
// Maximum length of uri
const TInt KMaximumMailboxUriLength = 64;

// ----------------------------------------------------------------------------
// CPsMruAdapter::NewL
// Two Phase Construction
// ----------------------------------------------------------------------------
CPsMruAdapter* CPsMruAdapter::NewL( TAny* aPsDataPluginParameters )
	{
	PRINT ( _L( "Enter CPsMruAdapter::NewL" ) );

	// Get the PsData plugin parametrs
	TPsDataPluginParams* params =
			reinterpret_cast<TPsDataPluginParams*>(aPsDataPluginParameters );
	CPsMruAdapter* self = new ( ELeave ) CPsMruAdapter();
	CleanupStack::PushL(self);
	self->ConstructL( params->iDataStoreObserver, params->iStoreListObserver );
	CleanupStack::Pop( self );

	PRINT ( _L( "End CPsMruAdapter::NewL" ) );

	return self;
	}

// ----------------------------------------------------------------------------
// CPsMruAdapter::CPsMruAdapter
// Two Phase Construction
// ----------------------------------------------------------------------------
CPsMruAdapter::CPsMruAdapter()
	{
	PRINT ( _L( "Enter CPsMruAdapter::CPsMruAdapter" ) );
	PRINT ( _L( "End CPsMruAdapter::CPsMruAdapter" ) );
	}

// ----------------------------------------------------------------------------
// CPsMruAdapter::ConstructL
// Two Phase Construction
// ----------------------------------------------------------------------------
void CPsMruAdapter::ConstructL( MDataStoreObserver* aObserverForDataStore,
		MStoreListObserver* aStoreListObserver )
	{
	PRINT ( _L( "Enter CPsMruAdapter::ConstructL" ) );

	// Mail client for FS Email framework
	iMailClient = CFSMailClient::NewL();

	// Register as observer for mail client, we'll need this to observe MRU list changes
	// When i.e mail is sent
	iMailClient->AddObserverL( *this );

	// This updates the list of all the supported datastores
	UpdateSupportedDataStoresList();

	// Store these for later use
	iDataStoreObserver = aObserverForDataStore;
	iStoreListObserver = aStoreListObserver;

	PRINT ( _L( "End CPsMruAdapter::ConstructL" ) );
	}

// ----------------------------------------------------------------------------
// CPsMruAdapter::~CPsMruAdapter
// Destructor
// ----------------------------------------------------------------------------
CPsMruAdapter::~CPsMruAdapter()
    {
    PRINT ( _L( "Enter CPsMruAdapter::~CPsMruAdapter" ) );

    iSupportedUris.ResetAndDestroy();

    // Remove observer, we don't need it anymore because we're shutting down
    RemoveAllMailboxObservers();
    iObservedMailboxes.Close();

    if ( iMailClient )
        {
        iMailClient->RemoveObserver( *this );
        iMailClient->Close();
        }

    PRINT ( _L( "End CPsMruAdapter::~CPsMruAdapter" ) );
    }

// ----------------------------------------------------------------------------
// CPsMruAdapter::RequestForDataL
// 
// ----------------------------------------------------------------------------
void CPsMruAdapter::RequestForDataL( TDesC& aDataStoreURI )
	{
	PRINT ( _L( "Enter CPsMruAdapter::RequestForDataL" ) );

	// Add data to datastore, fill only requested one
	FillDataStoreL( aDataStoreURI );

	PRINT ( _L( "Enter CPsMruAdapter::RequestForDataL" ) );
	}

// ----------------------------------------------------------------------------
// CPsMruAdapter::GetSupportedDataStoresL
// 
// ----------------------------------------------------------------------------

void CPsMruAdapter::GetSupportedDataStoresL(
		RPointerArray<TDesC> &aDataStoresURIs )
	{
	for ( TInt i = 0; i < iSupportedUris.Count(); i++ )
		{
		aDataStoresURIs.Append( iSupportedUris[i] );
		}
	}

// ----------------------------------------------------------------------------
// CPsMruAdapter::RequestForDataExtensionL
// 
// ----------------------------------------------------------------------------
TAny* CPsMruAdapter::RequestForDataExtensionL(TInt /*aItemId*/)
	{
	// No extention required for this since we have and interger as itemId
	// Simply return NULL
	return NULL;
	}

// ----------------------------------------------------------------------------
// CPsMruAdapter::UpdateSupportedDataStoresList
// 
// ----------------------------------------------------------------------------
void CPsMruAdapter::UpdateSupportedDataStoresList()
	{
	// Mailboxes will be fetched to this array
	RPointerArray<CFSMailBox> mailBoxes;

	// List all mailboxes
	TFSMailMsgId plugin;
	iMailClient->ListMailBoxes( plugin, mailBoxes );

	iSupportedUris.ResetAndDestroy();

	// Add all mailboxes as data stores
	for ( TInt i = 0; i < mailBoxes.Count(); i++ )
		{
		// Get id of mailbox
		TFSMailMsgId id = mailBoxes[i]->GetId();

		// Convert it to string, this will be the unique identifier for this mailbox
		HBufC* identifier = HBufC::New( KMaximumMailboxUriLength );
		if ( identifier && GetUriFromMailboxIdentifier( id, *identifier ) )
			{
			// Add to supported Uris list
			if ( iSupportedUris.Append( identifier ) == KErrNone )
			    {
			    // Ownership of the string is successfully moved to the array
			    identifier = NULL;
			    }
			}
		delete identifier;
		}

	// Release allocated memory
	mailBoxes.ResetAndDestroy();
	}

// ----------------------------------------------------------------------------
// CPsMruAdapter::FillDataStoreL
// ----------------------------------------------------------------------------
TBool CPsMruAdapter::FillDataStoreL( TDesC& aDataStoreURI )
	{
	TBool result = EFalse;

	TFSMailMsgId dataStoreId;

	if ( GetMailboxIdentifierFromUri( aDataStoreURI, dataStoreId ) )
		{
		result = FillDataStoreL( dataStoreId, aDataStoreURI );
		}

	return result;
	}

TBool CPsMruAdapter::FillDataStoreL( TFSMailMsgId& aId )
	{
	TBool result = EFalse;

	// Create Uri for this mailbox
	HBufC* identifier = HBufC::NewLC( KMaximumMailboxUriLength );
	if ( GetUriFromMailboxIdentifier( aId, *identifier ) )
		{
		result = FillDataStoreL( aId, *identifier );
		}
	CleanupStack::PopAndDestroy( identifier );
	return result;
	}

TBool CPsMruAdapter::FillDataStoreL( TFSMailMsgId& aId, TDesC& aDataStoreURI )
	{
	TBool result = EFalse;

	// Mailboxes will be fetched to this array
	RPointerArray<CFSMailBox> mailBoxes;
	CleanupResetAndDestroyPushL( mailBoxes );

	// List all mailboxes
	TFSMailMsgId plugin;
	iMailClient->ListMailBoxes( plugin, mailBoxes );

	// Find the requested mailbox
	for ( TInt i = 0; i < mailBoxes.Count(); i++ )
		{
		// Get id of mailbox
		TFSMailMsgId id = mailBoxes[i]->GetId();

		// Check that this is the requested mailbox
		if ( id == aId )
			{
			AddMailboxObserverL( aId );
			
			// update the caching status as InProgress
			iDataStoreObserver->UpdateCachingStatus( aDataStoreURI,
					ECachingInProgress );

			// Update datastore contents, first reset
			iDataStoreObserver->RemoveAll( aDataStoreURI );

			// Get MRU list for this mailbox
			MDesCArray* mruList = mailBoxes[i]->ListMrusL();

			if ( mruList )
				{
				TInt entryIndex = 0;
	
				// Add all data to data store, the format is:
				// index0: displayname
				// index1: email
				// index2: next displayname
				// index3: next email
				// etc..
				for ( int mruIndex = 0; mruIndex < mruList->MdcaCount(); mruIndex += 2 )
					{
					TPtrC displayName = mruList->MdcaPoint( mruIndex );
					TPtrC emailAddress = mruList->MdcaPoint( mruIndex + 1 );
	
					CPsData* mruData = CPsData::NewL();
					mruData->SetId( entryIndex++ );
	
					// Set the data
					mruData->SetDataL( 0, displayName );
					mruData->SetDataL( 1, KNullDesC );
					mruData->SetDataL( 2, emailAddress );
	
					iDataStoreObserver->AddData( aDataStoreURI, mruData );
					}
	
				delete mruList;
				}
			// update the caching status as Complete
			iDataStoreObserver->UpdateCachingStatus( aDataStoreURI,
					ECachingComplete );

			result = ETrue;
			break;
			}
		}

	CleanupStack::PopAndDestroy( &mailBoxes );
	return result;
	}

// ----------------------------------------------------------------------------
// CPsContactDataAdapter::IsDataStoresSupportedL
// 
// ----------------------------------------------------------------------------
TBool CPsMruAdapter::IsDataStoresSupportedL( TDesC& aDataStoreURI )
	{
	for ( TInt i = 0; i < iSupportedUris.Count(); i++ )
		{
		if ( iSupportedUris[i]->Compare( aDataStoreURI ) == 0 )
			return ETrue;
		}

	return EFalse;
	}

// ----------------------------------------------------------------------------
// CPsContactDataAdapter::GetSupportedDataFieldsL
// 
// ----------------------------------------------------------------------------
void CPsMruAdapter::GetSupportedDataFieldsL( RArray<TInt>& aDataFields )
	{
	aDataFields.Append( R_VPBK_FIELD_TYPE_FIRSTNAME );
	aDataFields.Append( R_VPBK_FIELD_TYPE_LASTNAME );
	aDataFields.Append( R_VPBK_FIELD_TYPE_EMAILGEN );
	}

TBool CPsMruAdapter::GetMailboxIdentifierFromUri( TDesC& aUri, TFSMailMsgId& aId )
	{
	// Find first separator in reverse order
	TInt lastSeparator = aUri.LocateReverseF( KDefaultMailBoxURISeparator );
	if ( lastSeparator == KErrNotFound )
		return EFalse;

	// This is where plugin id string starts
	TInt pluginIdStartPosition = KDefaultMailBoxURI().Length();
	TInt mailboxIdStartPosition = lastSeparator + 1;

	// It cannot be further than mailbox id
	if ( pluginIdStartPosition >= mailboxIdStartPosition )
		return EFalse;

	// Use TLex to convert string to integer
	TLex pluginIdConverter( aUri.Mid( pluginIdStartPosition,
			mailboxIdStartPosition - pluginIdStartPosition - 1 ) );

	// Use TLex to convert string to integer
	TLex mailboxIdConverter( aUri.Mid( mailboxIdStartPosition, aUri.Length()
			- mailboxIdStartPosition ) );

	TInt pluginId;
	TInt mailboxId;

	// Get plugin ID
	if ( pluginIdConverter.Val( pluginId ) != KErrNone)
		return EFalse;

	// Get mailbox ID
	if ( mailboxIdConverter.Val( mailboxId ) != KErrNone)
		return EFalse;

	// Store and we're ready
	aId.SetPluginId( TUid::Uid( pluginId ) );
	aId.SetId( mailboxId );

	return ETrue;
	}

TBool CPsMruAdapter::GetUriFromMailboxIdentifier( TFSMailMsgId& aId, HBufC& aUri )
	{
	// Add the uri identifier
	aUri.Des().Copy( KDefaultMailBoxURI );
	// Add plugin ID
	aUri.Des().AppendNum( aId.PluginId().iUid );
	// Add separator
	aUri.Des().Append( KDefaultMailBoxURISeparator );
	// Add mailbox id
	aUri.Des().AppendNum( aId.Id() );

	return true;
	}

void CPsMruAdapter::EventL( TFSMailEvent aEvent, TFSMailMsgId aMailbox,
		TAny* /*aParam1*/, TAny* aParam2, TAny* /*aParam3*/ )
	{
	switch ( aEvent )
		{
		case TFSEventMailMoved:
		case TFSEventMailCopied:		
		case TFSEventNewMail:
			{
			// Check the new parent folder id for this message
			// For all these events, param2 indicates the new parent folder
			TFSMailMsgId* parentFolderId =
					static_cast< TFSMailMsgId* >( aParam2 );
			if ( parentFolderId )
				{
				// Get the parent folder object
				CFSMailFolder* parentFolder = iMailClient->GetFolderByUidL(
						aMailbox, *parentFolderId );
				if ( parentFolder )
					{
					CleanupStack::PushL( parentFolder );

					// If it's sent/outbox folder,
					// we'll consider that as a new message being sent
					// and therefore we'll update the MRU list here
					if ( ( parentFolder->GetFolderType() == EFSSentFolder ) || 
						 ( parentFolder->GetFolderType() == EFSOutbox ) )
						{
						FillDataStoreL( aMailbox );
						}
					CleanupStack::PopAndDestroy( parentFolder );
					}
				}
			}
			break;
			
		case TFSEventNewMailbox:
			{
			HBufC* identifier = HBufC::NewLC( KMaximumMailboxUriLength );
			if ( GetUriFromMailboxIdentifier( aMailbox, *identifier ) )
				{
				// Add to supported Uri list
				iSupportedUris.AppendL( identifier );

				// Add new data store to cache
				iStoreListObserver->AddDataStore( *identifier );

				// Add all data to data store
				FillDataStoreL( *identifier );

				CleanupStack::Pop( identifier );
				}
			else
				{
				CleanupStack::PopAndDestroy( identifier );
				}
			}
			break;

		case TFSEventMailboxDeleted:
			{
			HBufC* identifier = HBufC::NewL( KMaximumMailboxUriLength );
			if ( GetUriFromMailboxIdentifier( aMailbox, *identifier ) )
				{
				RemoveMailboxObserver( aMailbox );
				
				// Remove data store from cache
				iStoreListObserver->RemoveDataStore( *identifier );

				// Remove from supported Uri list
				for ( TInt i = 0; i < iSupportedUris.Count(); i++ )
					{
					if ( iSupportedUris[i]->Compare( *identifier ) == 0 )
						{
						delete iSupportedUris[i];
						iSupportedUris.Remove( i );
						break;
						}
					}
				}
			delete identifier;
			}
			break;
		}
	}

TBool CPsMruAdapter::AddMailboxObserverL( TFSMailMsgId& aId )
	{
	for( TInt index = 0; index < iObservedMailboxes.Count(); index++ )
		{
		if( iObservedMailboxes[index] == aId )
			{
			// Already observing
			return EFalse;
			}
		}
	
	iMailClient->SubscribeMailboxEventsL( aId, *this );
	iObservedMailboxes.Append( aId );
	return ETrue;
	}

TBool CPsMruAdapter::RemoveMailboxObserver( TFSMailMsgId& aId )
	{
	for( TInt index = 0; index < iObservedMailboxes.Count(); index++ )
		{
		if( iObservedMailboxes[index] == aId )
			{
			iMailClient->UnsubscribeMailboxEvents( aId, *this );
			iObservedMailboxes.Remove( index );
			return ETrue;
			}
		}
	
	return EFalse;
	}

void CPsMruAdapter::RemoveAllMailboxObservers()
	{
	for( TInt index = 0; index < iObservedMailboxes.Count(); index++ )
		{
		iMailClient->UnsubscribeMailboxEvents( iObservedMailboxes[index], *this );
		}

	iObservedMailboxes.Reset();	
	}


// End of file