// 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:
//

#include <s32strm.h>
#include <csendasaccounts.h>

const TInt KMessageAccountArrayGranularity = 8;
const TInt16 KStreamVersionSendAs2Account = 1;
const TInt KMaxSendAs2AccountNameLength = 1024;

/**
Create a new CSendAsAccount.

@return
If the function succeeds, this is a pointer to a newly allocated and initialised
object.
*/
EXPORT_C CSendAsAccounts* CSendAsAccounts::NewL()
	{
	CSendAsAccounts *self = new (ELeave) CSendAsAccounts;
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

/**
Destructor.
*/	
EXPORT_C CSendAsAccounts::~CSendAsAccounts()
	{
	delete iAccountNames;
	iAccounts.Close();
	}

/**
The UID of the message type.

@return
The UID of the message type.
*/
EXPORT_C TUid CSendAsAccounts::MessageType() const
	{
	return iMessageType;
	}
	
/**
The array of names of accounts for this message type.

@return
An array of name of accounts.
*/
EXPORT_C const MDesCArray& CSendAsAccounts::AccountNames() const
	{
	return (*iAccountNames);
	}
	
/**
The account specified by the index argument.

@param	aIndex
The index of the specified account.

@return
The account specified by the index argument.
*/
EXPORT_C TSendAsAccount CSendAsAccounts::Account(TInt aIndex) const
	{
	return iAccounts[aIndex];
	}
	
/**
The number of accounts for this message type.

@return
The number of accounts.
*/
EXPORT_C TInt CSendAsAccounts::Count() const
	{
	return iAccountNames->Count();
	}

/**
Deletes all elements from the array.
*/
EXPORT_C void CSendAsAccounts::Reset()
	{
	iAccountNames->Reset();
	iAccounts.Reset();
	}
	
/**
The name associated with the given account.

@param aAccount
The account whose associated name is to be returned.

@return
A descriptor holding the associated name.
*/
EXPORT_C TPtrC CSendAsAccounts::NameFromAccountL(const TSendAsAccount aAccount) const
	{
	TInt nameIndex = User::LeaveIfError(iAccounts.Find(aAccount));
	return (*iAccountNames)[nameIndex];
	}
	
/**
The account associated with the given name.

@param aName
The associated name for the account to be returned.

@return
An account for the associated name.

@leave  KErrNotFound
An account with the given name cannot be found.
*/
EXPORT_C TSendAsAccount CSendAsAccounts::AccountFromNameL(const TDesC& aName) const
	{
	TInt acctIndex;
	if (iAccountNames->Find(aName, acctIndex) != 0)
		{
		User::Leave(KErrNotFound);
		}
	return iAccounts[acctIndex];
	}

/**
Internalizes the object from the specified stream.

@see
RMsvReadStream

@param aReadStream
The stream to read from.

@internalComponent
*/
EXPORT_C void CSendAsAccounts::InternalizeL(RReadStream& aReadStream)
	{
	aReadStream.ReadInt16L(); // version - not used yet

	aReadStream >> iMessageType;

	TInt count = aReadStream.ReadInt32L();

	Reset();

	TSendAsAccount sendAsAccount;
	for (TInt i = 0; i < count; ++i)
		{
		HBufC* buf = HBufC::NewLC(aReadStream, KMaxSendAs2AccountNameLength);
		aReadStream >> sendAsAccount;
		AppendAccountL(*buf, sendAsAccount);
		
		CleanupStack::PopAndDestroy(buf);
		}
	}


/**
Externalizes the object from the specified stream.

@see
RMsvWriteStream

@param aWriteStream
The stream to write out to.

@internalComponent
*/
EXPORT_C void CSendAsAccounts::ExternalizeL(RWriteStream& aWriteStream) const
	{
	__ASSERT_ALWAYS((iAccountNames->Count() == iAccounts.Count()), User::Invariant());
	
	aWriteStream.WriteInt16L(KStreamVersionSendAs2Account); // Version number
	aWriteStream << iMessageType; // Message type

	TInt count = iAccountNames->Count();	
	aWriteStream.WriteInt32L(count); // The count of name, uid object pairs to write out.

	for (TInt i = 0; i < count; ++i)
		{
		if ((*iAccountNames)[i].Length() > KMaxSendAs2AccountNameLength)
			{
			// Limit the string length if necessary.
			aWriteStream.WriteL((*iAccountNames)[i], KMaxSendAs2AccountNameLength);
			}
		else
			{
			aWriteStream << (*iAccountNames)[i];
			}
		aWriteStream << iAccounts[i];
		}
	}

/**
Sets UID of the message type.

@param aMessageType
The UID of the message type.
*/
EXPORT_C void CSendAsAccounts::SetMessageType(TUid aMessageType)
	{
	iMessageType = aMessageType;
	}

/**
Appends a new account and associated name pair.

@param aAccountName
The human readable name with which to associate with the given account.

@param aAccount
The account to add.
*/	
EXPORT_C void CSendAsAccounts::AppendAccountL(const TDesC& aAccountName, TSendAsAccount aAccount)
	{
	iAccounts.AppendL(aAccount);
	TRAPD(err, iAccountNames->AppendL(aAccountName));
	if (err != KErrNone)
		{
		iAccounts.Remove(iAccounts.Count() - 1);
		User::Leave(err);
		}
	}	

/**
Removes an existing account and associated name pair.

@param aIndex
The index of the entry to remove.
*/
EXPORT_C void CSendAsAccounts::RemoveAccount(TInt aIndex)
	{
	iAccountNames->Delete(aIndex);
	iAccounts.Remove(aIndex);
	}

/**
Gives the size of the accounts collection.

@return
The size of the accounts collection.
*/
EXPORT_C TInt CSendAsAccounts::Size() const
	{
	const TInt acctSize(sizeof(TSendAsAccount));
	const TInt tIntSize(sizeof(TInt));
	TInt totalSize = sizeof(TInt16) + sizeof(TUid); // The version and message type.
	TInt count = iAccountNames->Count();

	totalSize += tIntSize; // Size of the number of accounts

	for (TInt i = 0; i < count; ++i)
		{
		// Each account consists of an integer which tells us the size of the
		// account name, the account name, and the the TSendAsAccount data. We must
		// add the size of each of these items to the total.
		// Note that when externalizing an account, we don't explicitly write out an
		// integer containing the size of the account name, but the externalize
		// routine for the descriptor will write one out, so we must include it in
		// our calculation here.
		totalSize += tIntSize + (*iAccountNames)[i].Size() + acctSize;
		}

	return totalSize;
	}
	
CSendAsAccounts::CSendAsAccounts()
: iMessageType(KNullUid), iAccounts(KMessageAccountArrayGranularity)
	{
	}
	
void CSendAsAccounts::ConstructL()
	{
	iAccountNames = new (ELeave) CDesCArrayFlat(KMessageAccountArrayGranularity);
	}