// Copyright (c) 2004-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:
// csendastestclientmtm.cpp
//
#include "csendastestclientmtm.h"

#include <msvids.h>
#include <msvuids.h>
#include <txtrich.h>

#include "csendastestaddress.h"
#include "csendastestsendoperation.h"
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  
#include "msvconsts.h"
#endif

const TInt KSendAsTestMtmMaxBodySize	= 0x100;
const TInt KSendAsTestMtmMaxMessageSize	= 0x200;

EXPORT_C CSendAsTestClientMtm* CSendAsTestClientMtm::NewL(CRegisteredMtmDll& aRegisteredMtmDll, CMsvSession& aSession)
	{
	CSendAsTestClientMtm* self = new (ELeave) CSendAsTestClientMtm(aRegisteredMtmDll, aSession);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}
	
CSendAsTestClientMtm::~CSendAsTestClientMtm()
	{
	delete iSendAsTestMessage;
	}

CSendAsTestClientMtm::CSendAsTestClientMtm(CRegisteredMtmDll& aRegisteredMtmDll, CMsvSession& aSession)
: CBaseMtm(aRegisteredMtmDll, aSession)
	{
	}
	
void CSendAsTestClientMtm::ConstructL()
	{
	// Find the default service...
    TMsvSelectionOrdering ordering(KMsvNoGrouping, EMsvSortByNone, ETrue);
    CMsvEntry* entry = CMsvEntry::NewL(Session(), KMsvRootIndexEntryId, ordering);
    CleanupStack::PushL(entry);
	
 	CMsvEntrySelection* sel = entry->ChildrenWithMtmL(KUidMsgTypeSendAsTest);
	CleanupStack::PushL(sel);
	if( sel->Count() == 0 )
		{
		// There is no service - create it.
		TMsvEntry service;
		service.iMtm = KUidMsgTypeSendAsTest;
		service.iType = KUidMsvServiceEntry;
		service.SetReadOnly(EFalse);
		service.SetVisible(ETrue);
		
		entry->SetEntryL(KMsvRootIndexEntryId);
		entry->CreateL(service);
		
		iServiceId = service.Id();
		}
	else
		{
		iServiceId = sel->At(0);		
		}
	CleanupStack::PopAndDestroy(2, entry);	// entry, sel
	
	// Switch the context - this will initialise various objects in the base.	
	SwitchCurrentEntryL(KMsvRootIndexEntryId);
	
	iSendAsTestMessage = CSendAsTestMessage::NewL();
	}
	
void CSendAsTestClientMtm::DoAddAddresseeL(const TDesC& aAddress, const TDesC& aAlias, CSendAsTestMessage::TSendAsTestAddressType aType)
	{
	// Need to ensure that the message address list and the addressee list stay
	// in sync. First create the address object that will be added to the message
	// address list.	
	CSendAsTestAddress* address = CSendAsTestAddress::NewL();
	CleanupStack::PushL(address);
	address->SetAddressL(aAddress);
	address->SetAliasL(aAlias);
	address->SetAddressType(aType);
	
	// Add the address info to the addressee list - if this fails then ok as
	// message list has not been added to.
	AddToAddresseeListL(aAddress, aAlias);
	
	// Now add to the message address list...
	RPointerArray<CSendAsTestAddress>& array = iSendAsTestMessage->Addresses();
	TInt err = array.Append(address); 
	if( err != KErrNone )
		{
		// Could not add address to the message address list - remove the last
		// added address from the addressee list.
		iAddresseeList->Delete(iAddresseeList->Count()-1);
		User::Leave(err);
		}
	else
		{
		// The address was successfully added - pop off the cleanup stack.
		CleanupStack::Pop(address);		
		}
	}
	
void CSendAsTestClientMtm::AddToAddresseeListL(const TDesC& aAddress, const TDesC& aAlias)
	{
	// Append address to addressee list...
	if( aAlias.Length() > 0 )
		{
		HBufC* buf = HBufC::NewLC(aAlias.Length() + aAddress.Length() + 3);
		TPtr ptr = buf->Des();
		ptr.Copy(aAlias);
		ptr.Append(' ');
		ptr.Append('<');
		ptr.Append(aAddress);
		ptr.Append('>');
		iAddresseeList->AppendL(ptr);
		CleanupStack::PopAndDestroy(buf);		
		}
	else
		{
		iAddresseeList->AppendL(aAddress);
		}	
	}

void CSendAsTestClientMtm::Reset()
	{
	// Reset the two address lists.
	if( iAddresseeList != NULL )
		{
		iAddresseeList->Reset();
		}
	if( iSendAsTestMessage != NULL )		
		{
		iSendAsTestMessage->Addresses().ResetAndDestroy();	
		}	
	}

/*
 * from CBaseMtm
 */
 
void CSendAsTestClientMtm::SaveMessageL()
	{
	__ASSERT_DEBUG( iMsvEntry != NULL, User::Invariant() );

	CMsvStore* store = iMsvEntry->EditStoreL();
	CleanupStack::PushL(store);
	
	switch( iMsvEntry->Entry().iType.iUid )
		{
	case KUidMsvServiceEntryValue:
	case KUidMsvFolderEntryValue:
		break;
	case KUidMsvMessageEntryValue:
		{
		iSendAsTestMessage->StoreL(*store);
		StoreBodyL(*store);
		TMsvEntry entry(iMsvEntry->Entry());
		if (iSendAsTestMessage->BioType() != KNullUid)
			{
			entry.iBioType = iSendAsTestMessage->BioType().iUid;
			}
		
		iMsvEntry->ChangeL(entry);

		} break;
	default:
		User::Invariant();
		}	
	store->CommitL();

 	// Set the iSize member of the TMsvEntry
 	if( iMsvEntry->HasStoreL() )
 		{
 		const TInt size = store->SizeL();
		TMsvEntry entry(iMsvEntry->Entry());
 		if( entry.iSize != size )
 			{
 			entry.iSize = size;
 			iMsvEntry->ChangeL(entry);
 			}
 		}
	CleanupStack::PopAndDestroy(store);
	}
	
void CSendAsTestClientMtm::LoadMessageL()
	{
	__ASSERT_DEBUG( iMsvEntry != NULL, User::Invariant() );

	Reset();
	Body().Reset();

	CMsvStore* store = iMsvEntry->ReadStoreL();
	CleanupStack::PushL(store);
	
	switch( iMsvEntry->Entry().iType.iUid )
		{
	case KUidMsvServiceEntryValue:
	case KUidMsvFolderEntryValue:
		break;
	case KUidMsvMessageEntryValue:
		{
		CSendAsTestMessage* message = CSendAsTestMessage::NewL();
		CleanupStack::PushL(message);

		// Restore the message from the store and populate the addressee list.
		message->RestoreL(*store);
		
		const RPointerArray<CSendAsTestAddress>& addresses = message->Addresses();
		TInt count = addresses.Count();
	
		for( TInt i=0; i<count; ++i )
			{
			const CSendAsTestAddress& address = *addresses[i];
			AddToAddresseeListL(address.Address(), address.Alias());
			}

		store->RestoreBodyTextL(Body());

		CleanupStack::Pop(message); 
		delete iSendAsTestMessage;
		iSendAsTestMessage = message;
		} break;
	default:
		User::Invariant();
		}
	CleanupStack::PopAndDestroy(store);
	}

TMsvPartList CSendAsTestClientMtm::ValidateMessage(TMsvPartList /*aPartList*/)
	{
	TMsvPartList retList = 0;
	return retList;
	}
	
TMsvPartList CSendAsTestClientMtm::Find(const TDesC& /*aTextToFind*/, TMsvPartList /*aPartList*/)
	{
	TMsvPartList retList = 0;
	return retList;
	}

CMsvOperation* CSendAsTestClientMtm::ReplyL(TMsvId /*aDestination*/, TMsvPartList /*aPartlist*/, TRequestStatus& aCompletionStatus)
	{
	TMsvEntry entry = iMsvEntry->Entry();
	TPckg<TMsvId> prog(entry.Id());
	return CMsvCompletedOperation::NewL(Session(), KUidMsgTypeSendAsTest, prog, entry.iServiceId, aCompletionStatus, KErrNotSupported);
	}
	
CMsvOperation* CSendAsTestClientMtm::ForwardL(TMsvId /*aDestination*/, TMsvPartList /*aPartList*/, TRequestStatus& aCompletionStatus)
	{
	TMsvEntry entry = iMsvEntry->Entry();
	TPckg<TMsvId> prog(entry.Id());
	return CMsvCompletedOperation::NewL(Session(), KUidMsgTypeSendAsTest, prog, entry.iServiceId, aCompletionStatus, KErrNotSupported);
	}

void CSendAsTestClientMtm::AddAddresseeL(TMsvRecipientType aType, const TDesC& aRealAddress)
	{
	DoAddAddresseeL(aRealAddress, KNullDesC(), (CSendAsTestMessage::TSendAsTestAddressType)aType);
	}
	
void CSendAsTestClientMtm::AddAddresseeL(TMsvRecipientType aType, const TDesC& aRealAddress, const TDesC& aAlias)
	{
	DoAddAddresseeL(aRealAddress, aAlias, (CSendAsTestMessage::TSendAsTestAddressType)aType);
	}

void CSendAsTestClientMtm::AddAddresseeL(const TDesC& aRealAddress)
	{
	DoAddAddresseeL(aRealAddress, KNullDesC(), CSendAsTestMessage::ESendAsTestAddressTypeTo);
	}

void CSendAsTestClientMtm::AddAddresseeL(const TDesC& aRealAddress, const TDesC& aAlias)
	{
	DoAddAddresseeL(aRealAddress, aAlias, CSendAsTestMessage::ESendAsTestAddressTypeTo);
	}

void CSendAsTestClientMtm::RemoveAddressee(TInt aIndex)
	{
	__ASSERT_DEBUG( iSendAsTestMessage->Addresses().Count() == iAddresseeList->Count(), User::Invariant() );
	
	// Remove the address from the addressee list and message address list.
	iAddresseeList->Delete(aIndex);
	iSendAsTestMessage->Addresses().Remove(aIndex);
	}
	
void CSendAsTestClientMtm::SetSubjectL(const TDesC& aSubject)
	{
	iSendAsTestMessage->SetSubjectL(aSubject);
	}
	
void CSendAsTestClientMtm::BioTypeChangedL(TUid aBioTypeUid)
	{
	iSendAsTestMessage->SetBioTypeL(aBioTypeUid);
	}

TInt CSendAsTestClientMtm::QueryCapability(TUid aCapability, TInt& aResponse)
	{
	TInt error = KErrNone;
	aResponse = ETrue;
	switch( aCapability.iUid )
		{
		case KUidMtmQueryMaxBodySizeValue:
			{
			aResponse = KSendAsTestMtmMaxBodySize;
			} break;
		case KUidMtmQueryMaxTotalMsgSizeValue:
			{
			aResponse = KSendAsTestMtmMaxMessageSize;
			} break;
		case KUidMtmQuerySupportedBodyValue:
			{
			aResponse = KMtm7BitBody + KMtm8BitBody + KMtm16BitBody;
			break;
			}
		case KUidMtmQueryCanSendMsgValue:
		case KUidMtmQuerySendAsMessageSendSupportValue:
		case KUidMtmQuerySupportAttachmentsValue:
		case KUidMtmQuerySupportSubjectValue:
			break;
		case KUidMtmQueryMaxRecipientCountValue:
			{
			aResponse = KErrNotFound;	// not limited
			} break;
		case KUidMtmQueryCanReceiveMsgValue:
		case KUidMtmQuerySupportsBioMsgValue:
		case KUidMtmQuerySupportsSchedulingValue:	
		case KUidMsvMtmQueryEditorUidValue:
		case KUidMtmQueryOffLineAllowedValue:
		case KUidMtmQuerySendAsRequiresRenderedImageValue:
		case KUidMtmQuerySendAsRenderingUidValue:
		case KUidMtmQuerySupportsFolderValue:
		case KUidMtmQuerySupportsRecipientTypeValue:
		default:
			error = KErrNotSupported;
			break;
		}
	return error;
	}

void CSendAsTestClientMtm::InvokeSyncFunctionL(TInt /*FunctionId*/, const CMsvEntrySelection& /*aSelection*/, TDes8& /*aParameter*/)
	{

	User::Invariant();
	}

CMsvOperation* CSendAsTestClientMtm::InvokeAsyncFunctionL(TInt aFunctionId,const CMsvEntrySelection& aSelection, TDes8& aParameter, TRequestStatus& aCompletionStatus)
	{
	CMsvOperation* op = NULL;
	
	switch( aFunctionId )
		{
	case KMTMStandardFunctionsSendMessage:
		{
		// perform a regular send with standardised progress information for SendAs2
		op =  CSendAsTestSendOperation::NewL(Session(), aSelection, aParameter, aCompletionStatus);		
		} break;
	default:
		op = Session().TransferCommandL(aSelection,aFunctionId,(TDesC8&)aParameter, aCompletionStatus);
		break;
		};
	return op;
	}

TMsvId CSendAsTestClientMtm::DefaultServiceL() const
	{
	return iServiceId;
	}

void CSendAsTestClientMtm::ContextEntrySwitched()
	{
	Reset();
	}

/*
 * from MMsvEntryObserver
 */
 
void CSendAsTestClientMtm::HandleEntryEvent(TMsvEntryEvent /*aEvent*/, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)
	{
	}