#include <badesca.h>

#include <vtoken.h>

#include <cntfldst.h>

#include <cntfield.h>

#include "cntvcardutils.h"

#include <cntdef.h>

#include <cntitem.h>

/**

 * Destructor

 */

CContactsAppToVCardConverter::~CContactsAppToVCardConverter()

    {

    delete iVCard;

    }

/** 

 * Constructor

 * 

 * @param aMachineUniqueId Integer unique to the database

 * @param aCharSet Default character set to pass to Versit parser component

 * @param aVCardVersion Version of vCard being exported

 */

CContactsAppToVCardConverter::CContactsAppToVCardConverter(TInt64 aMachineUniqueId, Versit::TVersitCharSet aCharSet, TVCardVersion aVCardVersion) :

	iMachineUniqueId(aMachineUniqueId),

	iCharSet(aCharSet),

	iVCardVersion(aVCardVersion),

	iFilter(0)

	{

	}

/** 

 * Convert a contact item into a vCard.

 * 

 * @param aMainItem Contact item to convert

 * @param aAgentItem Agent contact item to convert

 * @param aOption Export preferences (options available defined in CContactDatabase::TOptions)

 * @param aExportPrivateFields Specify whether private fields are exported

 * @return vCard representation of contact item

 */

CParserVCard* CContactsAppToVCardConverter::GetContactItemAsVCardL(CContactItem* aMainItem, CArrayPtr<CContactItem>* aAgentItemArray, TInt aOption, TBool aExportPrivateFields)

    {

    switch(iVCardVersion)

		{

		case EVCard21:

		case EPBAPVCard21:

			iVCard = CParserVCard::NewL();

		break;

		case EPBAPVCard30:

			iVCard = CParserVCard3::NewL();

		break;

		default:

		User::Leave(KErrArgument);

		break;

		}

	iVCard->SetDefaultCharSet(iCharSet);

	EncodeItemPropertiesL(*aMainItem,aOption);

	EncodeFieldPropertiesL(*aMainItem, aAgentItemArray, aOption, aExportPrivateFields);

    CParserVCard* vCard=iVCard;

    iVCard=NULL;

    return vCard;

    }

/** 

 * Encode the properties associated with a contact item which are not fields

 * 

 * @param aContactItem Contact item to export

 * @param aOption Export preferences (options available defined in CContactDatabase::TOptions)

 */

void CContactsAppToVCardConverter::EncodeItemPropertiesL(const CContactItem& aContactItem,TInt aOption)

	{

	TBool pbapExp = IsPBAPExport();

	if( !pbapExp || (pbapExp && NeedsToBeExported(EPropertyREV)) )

		{

		// PREQ234 stipulates that times are stored as UTC time; as long as we

		// put UTC time, we can assume that it's UTC time out.

		CParserPropertyValueDateTime* valueDateTime = CreateDateTimePropertyL(aContactItem.LastModified(), TVersitDateTime::EIsUTC);

		CleanupStack::PushL(valueDateTime);

		CParserProperty* property = CParserGroupedProperty::NewL(*valueDateTime, KVersitTokenREV, NULL, NULL);

		CleanupStack::Pop(valueDateTime);	

		iVCard->AddPropertyL(property); //takes ownership

		}

	if (!(aOption & CContactVCardConverter::EExcludeUid))

		{

		TPtrC guid=aContactItem.UidStringL(iMachineUniqueId);

		CParserPropertyValueHBufC* uidValue=CParserPropertyValueHBufC::NewL(guid);

		CleanupStack::PushL(uidValue);

		CParserProperty* uidproperty=CParserGroupedProperty::NewL(*uidValue,KVersitTokenUID,NULL,NULL);

		CleanupStack::Pop(uidValue);	

		iVCard->AddPropertyL(uidproperty); //takes ownership

		}

	}

/** 

 * Convert all CContactItemFields into VCard properties and add them to iVCard.

 * Contact fields with no value (ie. empty fields) are not exported.

 * 

 * @param aMainItem Contact item to convert

 * @param aAgentItem Agent contact item to convert

 * @param aOption Export preferences (options available defined in CContactDatabase::TOptions)

 * @param aExportPrivateFields Specify whether private fields are exported

 */

void CContactsAppToVCardConverter::EncodeFieldPropertiesL(const CContactItem& aContactItem, CArrayPtr<CContactItem>* aAgentItemArray, TInt aOption, TBool aExportPrivateFields)

	{

	CContactItemFieldSet& fieldSet = aContactItem.CardFields();

	TBool pbapExp = IsPBAPExport();

	// Name

	GetVCardNameL(fieldSet, aOption, aExportPrivateFields);

	if(GetExportVersion() == EVCard21)

		{

		GetVCardFormattedNameL(fieldSet,aOption,aExportPrivateFields);

		GetVCardNamePrnL(fieldSet, aOption, aExportPrivateFields);

		// Addresses (home, work, pref and general)

		GetVCardAddressL(aContactItem, KUidContactFieldVCardMapHOME, KVersitParam8Home, aOption, aExportPrivateFields);

		GetVCardAddressL(aContactItem, KUidContactFieldVCardMapWORK, KVersitParam8Work, aOption, aExportPrivateFields);

		GetVCardAddressL(aContactItem, KUidContactFieldVCardMapPREF, KVersitParam8Pref, aOption, aExportPrivateFields);

		GetVCardAddressL(aContactItem, KNullUid, KNullDesC8, aOption, aExportPrivateFields);

		// Organization Information (Company Name and Department Name)

		GetVCardOrgInfoL(fieldSet, aOption, aExportPrivateFields);

		}

	else if(pbapExp)

		{

		//check if the mapping is contained in the filter

		if(NeedsToBeExported(EPropertyFN))				

			{

			GetVCardFormattedNameL(fieldSet, aOption, aExportPrivateFields);

			}

		if(NeedsToBeExported(EPropertySOUND))

			{

			GetVCardNamePrnL(fieldSet, aOption, aExportPrivateFields);	

			}

		// Addresses (home, work, pref and general)

		if(NeedsToBeExported(EPropertyADR))

			{

			GetVCardAddressL(aContactItem, KUidContactFieldVCardMapHOME, KVersitParam8Home, aOption, aExportPrivateFields);

			GetVCardAddressL(aContactItem, KUidContactFieldVCardMapWORK, KVersitParam8Work, aOption, aExportPrivateFields);

			GetVCardAddressL(aContactItem, KUidContactFieldVCardMapPREF, KVersitParam8Pref, aOption, aExportPrivateFields);

			GetVCardAddressL(aContactItem, KNullUid, KNullDesC8, aOption, aExportPrivateFields);	

			}

		if(NeedsToBeExported(EPropertyORG))

			{

			// Organization Information (Company Name and Department Name)

			GetVCardOrgInfoL(fieldSet, aOption, aExportPrivateFields);	

			}

		}

	CContactItem* agentItem;

	TInt numAgent = 0;

	// Other fields

	TBool telFound = EFalse;

	const TInt count = fieldSet.Count();

	TInt agentcount=0;

	if(aAgentItemArray &&  aAgentItemArray->Count())

	agentcount = aAgentItemArray->Count();

	for (TInt ii = 0; ii < count; ++ii)

		{

		agentItem = NULL;

		const CContactItemField& field = fieldSet[ii];

		if (!field.Storage()->IsFull())

			continue;

		const CContentType& content=field.ContentType();

		TInt before=1;

		TInt total=0;

		for (TInt jj=0; jj<count; ++jj)

			{

			// This content type comparison should ignore insignificant content types (e.g. Pref et al).

			if (content==fieldSet[jj].ContentType())

				{

				if (jj<ii)

					{

					++before;

					}

				++total;

				}

			}

		if (total==1)

			{

			before=0;

			}

		if(field.StorageType() == KStorageTypeContactItemId && agentcount > 0)

			{

			agentItem = aAgentItemArray->At(numAgent);

			++numAgent;

			}

		MapContactFieldToVCardPropertyL(field, agentItem, aOption, before, aExportPrivateFields);

		if (field.ContentType().Mapping() == KUidContactFieldVCardMapTEL)

			{//at least one non empty telephone field exists

			telFound = ETrue;

			}

	    }

	//if the TEL property has been requested then it must be exported. If no non-empty

	//telephone fields have been found at this point create a single empty TEL property

	if (NeedsToBeExported(EPropertyTEL) && !telFound)

		{

		CParserPropertyValue* value = CParserPropertyValueHBufC::NewL(KNullDesC);	

		CleanupStack::PushL(value);

		CParserGroupedProperty* property = CParserGroupedProperty::NewL(*value, KVersitTokenTEL, NULL, NULL);

		CleanupStack::Pop(value);

		//ownership passed

		iVCard->AddPropertyL(property);	

	    }

    }

/**

 * Find an address field which does not correspond to the HOME or WORK field type

 * (i.e. a General Address).

 *

 * @return The index into the field set of the located field, or KErrNotFound if the field was not located

 */

TInt CContactsAppToVCardConverter::FindAddressFieldByMappingAndType(const CContactItemFieldSet& aFields, TFieldType aFieldType, TUid aMapping)

	{

	TInt pos = 0;

	if (aFieldType != KNullUid)

		{

		pos = aFields.Find(aFieldType, aMapping);

		}

	else

		{

		TBool fieldFound = EFalse;

		TInt startPos = KContactFieldSetSearchAll;

		while(!fieldFound && !(pos == KErrNotFound))

			{

			pos = aFields.FindNext(aMapping, startPos);

			startPos = pos + 1;

			if (pos != KErrNotFound )

				{

				const CContactItemField& tempField = aFields[pos];

				const CContentType& tempContentType = tempField.ContentType();

				TBool additionalMapFound = EFalse;

				additionalMapFound |= tempContentType.ContainsFieldType(KUidContactFieldVCardMapHOME);

				additionalMapFound |= tempContentType.ContainsFieldType(KUidContactFieldVCardMapWORK);

				additionalMapFound |= tempContentType.ContainsFieldType(KUidContactFieldVCardMapPREF);

				if (!additionalMapFound)

					{

					fieldFound = ETrue;

					}

				}

			}

		}

	return pos;

	}

/**

 * Retrieve an address field from the contact card's field set

 * 

 * @param aFields Contact item field set

 * @param aParams Array of CParserParam

 * @param aDesArray Descriptor array

 * @param aUid1 Contact model vCard mapping (ie. KUidContactFieldVCardMapXXX)

 * @param aUid2 Contact model vCard mapping (ie. KUidContactFieldVCardMapXXX)

 * @param aLabel Label name to append to standard KContactVCardXDashEPOCCNTMODEL property parameter extension 

 * @param aOption Export preferences (options available defined in CContactvCardConverter::TOptions)

 * @param aFound Field was found and is not empty

 * @param aExportPrivateFields Specify whether private fields are included

 * @param aWithoutPref If ETrue exclude preferred fields

 */

void CContactsAppToVCardConverter::RetrieveAddressFieldL(const CContactItemFieldSet& aFields, CArrayPtr<CParserParam>& aParams, CDesCArrayFlat& aDesArray, TFieldType aFieldType, TUid aMapping, const TDesC& aLabel, TInt aOption, TBool& aFound, TBool aExportPrivateFields, TBool aWithoutPref) const

	{

	const TInt pos = FindAddressFieldByMappingAndType(aFields, aFieldType, aMapping);

	const TBool processWhitespace = (aOption & CContactVCardConverter::EConnectWhitespace);

	if	(pos == KErrNotFound)

		{

		if (processWhitespace)

			{

			aDesArray.AppendL(KContactVCardCompositeSupportedButEmptyFieldValue);

			}

		else

			{

			aDesArray.AppendL(KNullDesC);

			}

		return;

		}

	const CContactItemField& field = aFields[pos];

	if (aFieldType == KUidContactFieldVCardMapHOME && field.ContentType().ContainsFieldType(KUidContactFieldVCardMapWORK))

		{

		// Only want to skip this field if it contains both the work mapping and 

		// we have searched on the home mapping.

		// 

		// Next time we come into this function it will be looking for the work mapping

		// i.e. aUid1==KUidContactFieldVCardMapWORK that way if an ADR is both work and home

		// it will only be processed once

		if (processWhitespace)

			{

			aDesArray.AppendL(KContactVCardCompositeSupportedButEmptyFieldValue);

			}

		else

			{

			aDesArray.AppendL(KNullDesC);

			}

		return;

		}

	if (aWithoutPref && field.ContentType().ContainsFieldType(KUidContactFieldVCardMapPREF))

		{

		if (processWhitespace)

			{

			aDesArray.AppendL(KContactVCardCompositeSupportedButEmptyFieldValue);

			}

		return;

		}

	// Assume we're not going to export this field - unless we find some real data

	TBool validItemToExport = EFalse;

	if (!field.IsPrivate() || aExportPrivateFields)

		{

		TBool onCleanupStack = EFalse;

		TPtrC pText(KNullDesC);

		// If the field contains text, then get the text and examine it depending on the flags.

		// Note that the text is created in another buffer, which is pushed onto the stack. This

		// will only happen if there is actually text - thus the need for the onCleanupStack flag.

		if	(field.TextStorage() && field.TextStorage()->IsFull())

			{

			// This step puts the std text onto the cleanup stack - set the flag so it can be 

			// cleaned up later.

			pText.Set(field.TextStorage()->StandardTextLC());

			onCleanupStack = ETrue;

			if (processWhitespace)

				{

				validItemToExport = CContactVCardConverter::ContainsExportableData(pText);

				}

			else

				{

				validItemToExport = ETrue;

				}

			}

		if	(validItemToExport)

			{

			aFound = ETrue;

			aDesArray.AppendL(pText);

			//

			const TBool includeX = aOption & CContactDatabase::EIncludeX;

 			const TPtrC label = field.Label();

  			if	(label.Size() && includeX && field.OverRidesLabel())

   				{

				TBuf8<KContactMaxVCardPropertyNameLength> param(KContactVCardXDashEPOCCNTMODEL);

   				param.Append(aLabel);

				//

				CParserParam* parserParam = CParserParam::NewL(param, label);

				CleanupStack::PushL(parserParam);

   				aParams.AppendL(parserParam);

				CleanupStack::Pop(parserParam);

   				}

			}

		if	(onCleanupStack)

			{

			CleanupStack::PopAndDestroy(); // StandardText

			}

		}

	if (!validItemToExport)

		{

		if (processWhitespace)

			{

			aDesArray.AppendL(KContactVCardCompositeSupportedButEmptyFieldValue);

			}

		else

			{

			aDesArray.AppendL(KNullDesC);

			}

		}

	}

/** 

 * Build up name of VCard from the N and FN properties 

 * 

 * @param aContact Contact item to export

 * @param aOption Export preferences (options available defined in CContactDatabase::TOptions)

 * @param aExportPrivateFields Specify whether private fields are included

 */ 

void CContactsAppToVCardConverter::GetVCardNamePrnL(CContactItemFieldSet& aFields,TInt aOption,TBool aExportPrivateFields)

	{

	// For property parameters (should they be necessary) for this exported property

	CArrayPtr<CParserParam>* arrayOfParams = new(ELeave) CArrayPtrFlat<CParserParam>(5);

	CleanupStack::PushL(TCleanupItem(CleanUpResetAndDestroy,arrayOfParams));

	// For the property value itself

	CDesCArrayFlat* desArray=new (ELeave)CDesCArrayFlat(4);

	CleanupStack::PushL(desArray);

	// Export each item in turn (where the field of the specified type is found 

	// in the contact card).

	TInt foundCount = 0;

	foundCount += LocateSpecificNameValueL(aFields, KUidContactFieldFamilyNamePronunciation,	*desArray, *arrayOfParams, KContactVCardLABEL0, aOption, aExportPrivateFields);

	foundCount += LocateSpecificNameValueL(aFields, KUidContactFieldGivenNamePronunciation,		*desArray, *arrayOfParams, KContactVCardLABEL1, aOption, aExportPrivateFields);

  	if (foundCount > 0)

		{

		CParserPropertyValue* value = new(ELeave) CParserPropertyValueCDesCArray(desArray);

	  	CleanupStack::Pop(desArray);

		//

	  	CleanupStack::PushL(value);

	  	CParserGroupedProperty* property = CParserGroupedProperty::NewL(*value,KVersitTokenSOUND, NULL, arrayOfParams);

	  	CleanupStack::Pop(2, arrayOfParams); // value, arrayOfParams

		CleanupStack::PushL(property);

  		CParserParam* param = CParserParam::NewL(KVersitParam8NamePrn, KNullDesC8);

		CleanupStack::PushL(param);

		property->AddParamL(param);

		CleanupStack::Pop(2,property); // + param

		// This pushes property before anything can leave...

		iVCard->AddPropertyL(property);

		}

	else

		{

  		CleanupStack::PopAndDestroy(2, arrayOfParams); // desArray, arrayOfParams

  		}

	}

/** 

 * Build up name of VCard from the N and FN properties 

 * 

 * @param aContact Contact item to export

 * @param aOption Export preferences (options available defined in CContactDatabase::TOptions)

 * @param aExportPrivateFields Specify whether private fields are included

 */ 

void CContactsAppToVCardConverter::GetVCardNameL(CContactItemFieldSet& aFields,TInt aOption,TBool aExportPrivateFields)

	{

	// For property parameters (should they be necessary) for this exported property

	CArrayPtr<CParserParam>* arrayOfParams = new(ELeave) CArrayPtrFlat<CParserParam>(5);

	CleanupStack::PushL(TCleanupItem(CleanUpResetAndDestroy,arrayOfParams));

	// For the property value itself

	CDesCArrayFlat* desArray=new (ELeave)CDesCArrayFlat(4);

	CleanupStack::PushL(desArray);

	// Export each item in turn (where the field of the specified type is found 

	// in the contact card).

	TInt foundCount = 0;

	foundCount += LocateSpecificNameValueL(aFields, KUidContactFieldFamilyName,		*desArray, *arrayOfParams, KContactVCardLABEL0, aOption, aExportPrivateFields);

	foundCount += LocateSpecificNameValueL(aFields, KUidContactFieldGivenName,		*desArray, *arrayOfParams, KContactVCardLABEL1, aOption, aExportPrivateFields);

	foundCount += LocateSpecificNameValueL(aFields, KUidContactFieldAdditionalName,	*desArray, *arrayOfParams, KContactVCardLABEL2, aOption, aExportPrivateFields);

	foundCount += LocateSpecificNameValueL(aFields, KUidContactFieldPrefixName,		*desArray, *arrayOfParams, KContactVCardLABEL3, aOption, aExportPrivateFields);

	foundCount += LocateSpecificNameValueL(aFields, KUidContactFieldSuffixName,		*desArray, *arrayOfParams, KContactVCardLABEL4, aOption, aExportPrivateFields);

	//The N property must be exported even if empty for vCard 2.1 and 3.0 

	//as per PBAP specification.

	if (foundCount == 0 && IsPBAPExport())

		{

		//replace with single empty name value so that property is N: instead of N:;;;;

		desArray->Reset();

		desArray->AppendL(KNullDesC);

		foundCount = 1; //forces the property to be created

		}

	if (foundCount > 0)

		{

		CParserPropertyValue* value = new(ELeave) CParserPropertyValueCDesCArray(desArray);

	  	CleanupStack::Pop(desArray);

		//

	  	CleanupStack::PushL(value);

	  	CParserGroupedProperty* property = CParserGroupedProperty::NewL(*value,KVersitTokenN, NULL, arrayOfParams);

	  	CleanupStack::Pop(2, arrayOfParams); // value, arrayOfParams

		// This pushes property before anything can leave...

		iVCard->AddPropertyL(property);

		}

	else

		{

  		CleanupStack::PopAndDestroy(2, arrayOfParams); // desArray, arrayOfParams

  		}

	}

/** 

 * Export address fields. This method exports the 7 address fields in the contact.

 * 

 * @param aContact Contact item to export

 * @param aVCardMapping UID specifying whether this is a HOME, WORK or PREF address

 * @param aToken The name of the vCard property parameter (eg. HOME, WORK, PREF)

 * @param aOption Export preferences (options available defined in CContactDatabase::TOptions)

 * @param aExportPrivateFields Specify whether private fields are included

 */ 

void CContactsAppToVCardConverter::GetVCardAddressL(const CContactItem& aContact, TUid aVCardMapping, const TDesC8& aToken, TInt aOption, TBool aExportPrivateFields)

	{

    CArrayPtr<CParserParam>* arrayOfParams = new(ELeave) CArrayPtrFlat<CParserParam>(5);

	CleanupStack::PushL(TCleanupItem(CleanUpResetAndDestroy, arrayOfParams));

	if	(aToken.Length())

		{	

		CParserParam* parserParam;

		//nameless parameters not allowed for vCard 3.0, so add "TYPE" parameter name 

		if (GetExportVersion() == EPBAPVCard30)

			{

			parserParam = CParserParam::NewL(KVersitTokenTYPE, aToken);

			}

		else

			{

			parserParam = CParserParam::NewL(aToken, KNullDesC);