#include "cntvcardutils.h"

// System includes

#include <badesca.h>

#include <conlist.h>

#include <s32mem.h> 

// User includes

#include <cntfldst.h>

#include <cntfield.h>

#include <cntdef.h>

#include <cntitem.h>

// Constants

const TInt KVCardImportAddressArrayGranularity = 4;

const TInt KContactGivenName = 1;

const TInt KContactFamilyName = 0;

const TInt KContactAdditionalName = 2;

const TInt KContactPrefixName = 3;

const TInt KContactSuffixName = 4;

const TInt KContactPostOffice = 0;

const TInt KContactExtendedAddress = 1;

const TInt KContactAddress = 2;

const TInt KContactLocality = 3;

const TInt KContactRegion = 4;

const TInt KContactPostcode = 5;

const TInt KContactCountry = 6;

/**

 * Delete name fields from a contact

 *

 * @param aContact Contact item

 */

void CVCardToContactsAppConverter::DeleteNameFields(CContactItem& aContact)

	{

	const CContactItemFieldSet& fieldSet = aContact.CardFields();

	//

	DeleteField(aContact, fieldSet, KUidContactFieldGivenName, KUidContactFieldVCardMapUnusedN);

	DeleteField(aContact, fieldSet, KUidContactFieldFamilyName, KUidContactFieldVCardMapUnusedN);

	DeleteField(aContact, fieldSet, KUidContactFieldAdditionalName, KUidContactFieldVCardMapUnusedN);

	DeleteField(aContact, fieldSet, KUidContactFieldPrefixName, KUidContactFieldVCardMapUnusedN);

	DeleteField(aContact, fieldSet, KUidContactFieldSuffixName, KUidContactFieldVCardMapUnusedN);

	}

/**

 * Delete a specific field from the contact card

 *

 * @param aContact The contact

 * @param aFieldSet The contact's field set

 * @param aFieldType The type of field to delete from the field set

 * @param aMapping The additional mapping which the field must contain for it to be deleted

 */

void CVCardToContactsAppConverter::DeleteField(CContactItem& aContact, const CContactItemFieldSet& aFieldSet, TFieldType aFieldType, TUid aMapping)

	{

	const TInt pos = aFieldSet.Find(aFieldType, aMapping);

	if	(pos != KErrNotFound)

		aContact.RemoveField(pos);

	}

void CVCardToContactsAppConverter::MergeSpecifiedNameFieldL(CContactItem& aContact, TFieldType aFieldType, CVCardItemAndLabel& aNames, TInt aOption, TInt aNameIndex)

/**

 * Merge specific name fields from a contact

 *

 * @param aContact Contact item to add fields to

 * @param aFieldType Field type of field to add (TFieldType)

 * @param aNames An object containing the name and labels for 'N' property fields

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

 * @param aNameIndex Index into aNames

 */

	{

	CContactItemFieldSet& oldfieldset=aContact.CardFields();

	const TInt pos = oldfieldset.Find(aFieldType, KUidContactFieldVCardMapUnusedN);

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

	// First check whether the field is present in the contact card

	// Also verify that the array of address sub-values actually contains a specific

	// value for the requested index.

	if (aNames.ItemCount() > aNameIndex)

		{

		const TPtrC pValue = aNames.Item(aNameIndex);

		const TInt length = pValue.Length();

		if (processWhitespace)

			{

			TBool isSingleSpace = EFalse;

			if (length == 1)

				{

				isSingleSpace = (pValue[0] == KContactVCardSpaceCharacter);

				}

			if	((pos != KErrNotFound) && (length || isSingleSpace))

				{

				// This means the PC side field is empty, so delete the corresponding device-side field.

				aContact.RemoveField(pos);

				}

			if	(length && !isSingleSpace)

				{

				// This means the PC side field is unsupported, so ignore the corresponding contents.

				TInt insertPos = 0;

				SetNameFieldL(aNames, aContact, aOption, aNameIndex, aFieldType, insertPos);

				}

			}

		else

			{

			if (pos != KErrNotFound)

				{

				// This means the PC side field is empty, so delete the corresponding device-side field.

				aContact.RemoveField(pos);

				}

			if (length)

				{

				// This means the PC side field is not empty, so add the corresponding contents.

				TInt insertPos = 0;

				SetNameFieldL(aNames, aContact, aOption, aNameIndex, aFieldType, insertPos);

				}

			}

		}

	}

void CVCardToContactsAppConverter::MergeNameFieldsL(CContactItem& aContact, CVCardItemAndLabel& aNames, TInt aOption, TBool aTreatAsPrn)

/**

 * Merge name fields from a contact

 *

 * @param aContact Contact item to add fields to

 * @param aNames An object containing the name and labels for 'N' property fields

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

 */

	{

	if(aTreatAsPrn)

		{

		MergeSpecifiedNameFieldL(aContact, KUidContactFieldGivenNamePronunciation,	aNames, aOption, KContactGivenName);

		MergeSpecifiedNameFieldL(aContact, KUidContactFieldFamilyNamePronunciation,	aNames, aOption, KContactFamilyName);

		}

	else

		{

		MergeSpecifiedNameFieldL(aContact, KUidContactFieldPrefixName,		aNames, aOption, KContactPrefixName);

		MergeSpecifiedNameFieldL(aContact, KUidContactFieldGivenName,		aNames, aOption, KContactGivenName);

		MergeSpecifiedNameFieldL(aContact, KUidContactFieldAdditionalName,	aNames, aOption, KContactAdditionalName);

		MergeSpecifiedNameFieldL(aContact, KUidContactFieldFamilyName,		aNames, aOption, KContactFamilyName);

		MergeSpecifiedNameFieldL(aContact, KUidContactFieldSuffixName,		aNames, aOption, KContactSuffixName);

		}

	}

void CVCardToContactsAppConverter::MergeSpecifiedAddressFieldL(CContactItem& aContact, const CVCardAddress& aAddress, const TUid& aFieldUid, const TUid& aMappingUid, TInt aAddressIndex, TInt aOption)

/**

 * Merge specific address fields from a contact

 *

 * @param aContact Contact item to add fields to

 * @param aUid The Uid of the contact

 * @param aFieldUid Contacts database Field ID

 * @param aMappingUid VCard Mapping ID

 * @param aAddress An object containing the name and labels for 'ADR' property fields

 * @param aAddressIndex Index into aAddress

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

 */

	{

	CContactItemFieldSet& oldfieldset = aContact.CardFields();

	TInt pos = 0;

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

	if (aAddress.Mapping() == KNullUid)

		{

		TBool fieldFound = EFalse;

		TInt startPos = KContactFieldSetSearchAll;

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

			{

			pos = oldfieldset.FindNext(aMappingUid, startPos);

			startPos = pos + 1;

			if (pos != KErrNotFound )

				{

				CContactItemField& tempField = oldfieldset[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;

					}

				}

			}

		}

	else

		{

		pos = oldfieldset.Find(aAddress.Mapping(), aMappingUid);

		}

	// First check whether the field is present in the contact card

	// Also verify that the array of address sub-values actually contains a specific

	// value for the requested index.

	if (aAddress.ItemCount() > aAddressIndex)

		{

		const TPtrC pValue = aAddress.Item(aAddressIndex);

		const TInt length = pValue.Length();

		if (processWhitespace)

			{

			TBool isSingleSpace = EFalse;

			if (length == 1)

				{

				isSingleSpace = (pValue[0] == KContactVCardSpaceCharacter);

				}

			if	((length || isSingleSpace) && (pos != KErrNotFound))

				{

				// This means the PC side field is empty, so delete the corresponding device-side field.

				aContact.RemoveField(pos);

				}

			if	(length && !isSingleSpace)

				{

				TInt insertPos = 0;

				SetAddressFieldL(aAddress, aContact, aOption, aAddressIndex, aFieldUid, insertPos, aMappingUid);

				}

			}

		else

			{

			if (pos != KErrNotFound)

				{

				// This means the PC side field is empty, so delete the corresponding device-side field.

				aContact.RemoveField(pos);

				}

			if (length)

				{

				// This means the PC side field is not empty, so add the corresponding contents.

				TInt insertPos = 0;

				SetAddressFieldL(aAddress, aContact, aOption, aAddressIndex, aFieldUid, insertPos, aMappingUid);

				}

			}

		}

	}

void CVCardToContactsAppConverter::MergeAddressFieldsL(CContactItem& aContact, const CVCardAddress& aAddress, TInt aOption)

/**

 * Merge a specific field from the contact card

 *

 * @param aContact Contact item to add fields to

 * @param aUid The Uid of the contact

 * @param aAddresses Address of locally stored contact

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

 */

	{

	MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldPostOffice, KUidContactFieldVCardMapPOSTOFFICE, KContactPostOffice, aOption);

	MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldExtendedAddress, KUidContactFieldVCardMapEXTENDEDADR, KContactExtendedAddress, aOption);

	MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldAddress, KUidContactFieldVCardMapADR, KContactAddress, aOption);

	MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldLocality, KUidContactFieldVCardMapLOCALITY, KContactLocality, aOption);

	MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldRegion, KUidContactFieldVCardMapREGION, KContactRegion, aOption);

	MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldPostcode, KUidContactFieldVCardMapPOSTCODE, KContactPostcode, aOption);

	MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldCountry, KUidContactFieldVCardMapCOUNTRY, KContactCountry, aOption);

	}

TBool CVCardToContactsAppConverter::MergeVCardWithContactItemL(CContactItem &aContact, CParserVCard& aVCard, TUnknownPropertyBehaviour aUnknownPropertyBehaviour, TInt aOption)

/**

 * Merge a vCard with an existing contact item

 *

 * @param aContact Contact item to add fields to

 * @param aVCard vCard parser object

 * @param aUnknownPropertyBehaviour Specifies how extension properties are handled

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

 * @return ETrue if contact item should be deleted, EFalse otherwise

 */

	{

	TInt ii = 0;

	TInt count = 0;

	//

	TBool deleteContact = ETrue;

	iUnknownPropertyBehaviour = aUnknownPropertyBehaviour;

	TTime lastModified;

	GetVCardModifiedTimeL(aVCard, lastModified);

	// We're performing a merge

	SetImportType(ECntVCardImportTypeMerge);

	// Get Name

	CVCardItemAndLabel* names = GetContactNameLC(aVCard, aOption);

	if	(names && names->ItemCount())

		{

		MergeNameFieldsL(aContact, *names, aOption);

		deleteContact = EFalse;

		}

	CleanupStack::PopAndDestroy(names);

	// Get Name pronunciation

 	names = GetContactNamePrnLC(aVCard, aOption);

 	if (names && names->ItemCount())

 		{

 		MergeNameFieldsL(aContact, *names, aOption, ETrue);

 		}

 	CleanupStack::PopAndDestroy(names);

	// Create address container

	RPointerArray<CVCardAddress> addresses(KVCardImportAddressArrayGranularity);

	CleanupStack::PushL(TCleanupItem(CVCardItemAndLabel::CleanUpResetDestroyAndCloseArray, &addresses));

	// Get addresses from the vCard. This actually only retrieves four types of addresses:

	// HOME, WORK, PREF and now additionally, 'general' addresses

	GetAddressesL(aVCard, aOption, addresses);

	// Import each of the located address field into the contact card

	count = addresses.Count();

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

		{

		const CVCardAddress* address = addresses[ii];

		MergeAddressFieldsL(aContact, *address, aOption);

		deleteContact = EFalse;

		}

	// Finished with addresses now, so clean up

	CleanupStack::PopAndDestroy(&addresses);

	// Get Organization related information from the vCard. This actually only retrieves the Company and the Department Name

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

	CleanupStack::PushL(orgList);

	TInt orgCount = GetVCardPropertyAsArrayOfValuesL(aVCard, KVersitTokenORG, *orgList);

	if(orgCount)

		{

		MergeOrgDetailsL(aContact,*orgList,aOption);

		deleteContact = EFalse;

		}

	CleanupStack::PopAndDestroy(orgList); // orgList

	// Get Single Instance of Class Field from the vCard.

	HBufC* singleClass = NULL;

	singleClass = HBufC::NewLC(256);

   	TPtr ptr(singleClass->Des());

	TInt classCount = GetSingleInstanceL(aVCard, KVersitTokenClass, ptr);

	if(classCount)

		{

		MergeSingleInstanceL(aContact,ptr,KUidContactFieldClass, KUidContactFieldVCardMapClass,aOption);

		deleteContact = EFalse;

		}

	CleanupStack::PopAndDestroy(singleClass);

	// Get other properties

	CArrayPtr<CParserProperty>* arrayOfProperties = aVCard.ArrayOfProperties();

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

	count = arrayOfProperties->Count();

	//Within this loop we store the content type of the last field updated.

	//If the content type of the current field matches, we update fieldCount

	//This holds the position of the field to update, to prevent us from

	//overwriting the field we just updated.

	TInt fieldCount = 0;

	CContactItemField* oldField = NULL;

	CContactItemField* newField = NULL;

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

 	  	{

        if (((*arrayOfProperties)[ii]->Name() != KVersitTokenADR) && ((*arrayOfProperties)[ii]->Name() != KVersitTokenORG) && ((*arrayOfProperties)[ii]->Name() != KVersitTokenClass))

		 {

		  TBool unsupportedProperty=EFalse;

			newField = GetVCardPropertyAsContactFieldLC((*arrayOfProperties)[ii], aOption,unsupportedProperty);

			if (newField)

				{

				TInt ttnumber;

				if (!oldField)

					{

					fieldCount = 1;

					ttnumber = 1;

					if (aOption & CContactVCardConverter::ETTFormat)

						{

						ttnumber = GetVCardPropertyTTNumber((*arrayOfProperties)[ii]);

						}

					}

				else if (newField->ContentType().IsEqualForSyncUpdate(oldField->ContentType()))

					{

					ttnumber = ++fieldCount;

					}

				else

					{

					fieldCount = 1;

					ttnumber = 1;

					if (aOption & CContactVCardConverter::ETTFormat)

						{

						ttnumber = GetVCardPropertyTTNumber((*arrayOfProperties)[ii]);

						}

					}

				if (oldField)

					{

					CleanupStack::Pop(); //newField

					CleanupStack::PopAndDestroy(oldField);

					oldField = NULL;

					CleanupStack::PushL(newField);

					}

				oldField = newField;

				aContact.CardFields().UpdateFieldSyncL(*newField, ttnumber);

				if(newField->Storage()->IsFull())

					{

					deleteContact = EFalse;

					}

				newField = NULL;	

				}

			else if (unsupportedProperty)

				{

				CleanupStack::Pop();

				deleteContact = EFalse;

				}

			else{

				CleanupStack::Pop();

				}

			}

    	}

    //Remove all empty fields after merge

    CContactItemFieldSet &fieldset = aContact.CardFields();

    TInt i = 0;

    for(; i < fieldset.Count(); ++i)

    	{

    	if( !fieldset[i].Storage()->IsFull() )

    		{

    		fieldset.Remove( i-- );

    		}

    	}

	if (newField)

		//coverity [dead_error_begin]

		{	

		CleanupStack::PopAndDestroy(newField);

		newField = NULL;

		}

	if (oldField)

		{

		CleanupStack::PopAndDestroy(oldField);

		oldField = NULL;

		}

	if (lastModified != Time::NullTTime())

		{

    	aContact.SetLastModified(lastModified);

		}

    CleanupStack::PopAndDestroy(arrayOfProperties);

	return(deleteContact);

	}

/**

 * Set a name field. Only creates a field if the specified name text is not empty.

 *

 * @param aNames An object containing the name and labels for 'N' property fields

 * @param aContact Contact item to add fields to

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

 * @param aIndex Array position of field to use

 * @param aFieldType Field type of field to add (TFieldType)

 * @param aInsertPos Position in contact field set to add field

*/

void CVCardToContactsAppConverter::SetNameFieldL(const CVCardItemAndLabel& aNames, CContactItem& aContact, TInt aOption, TInt aIndex, TFieldType aFieldType, TInt& aInsertPos) const

	{

	const TInt count = aNames.ItemCount();

	const TInt labelCount = aNames.LabelCount();

	//

	if	(aIndex >= 0 && aIndex < count)

		{

		const TPtrC pFieldText(aNames.Item(aIndex));

		TBool addField = EFalse;

		if (CContactVCardConverter::EConnectWhitespace & aOption)

			{

			addField = CContactVCardConverter::ContainsImportableData(pFieldText, CContactVCardConverter::EPropertyValueComposite, ImportType());

			}

		else

			{

			addField = (pFieldText.Length());

			}

		// Only add the field if it contains some data

		if	(addField)

			{

			CContactItemField* contactItemField = CContactItemField::NewLC(KStorageTypeText, aFieldType);

			contactItemField->SetMapping(KUidContactFieldVCardMapUnusedN);

			if ((aOption & CContactVCardConverter::EIncludeX) && (aIndex >= 0 && aIndex < labelCount))

				contactItemField->SetLabelL(aNames.Label(aIndex));

			//

			HBufC* encodedText = EncodeL(pFieldText, ETrue);

			contactItemField->TextStorage()->SetText(encodedText); // takes ownership

			aContact.InsertFieldL(*contactItemField, aInsertPos++);

			CleanupStack::Pop(contactItemField);

			}

		}

	}

HBufC* CVCardToContactsAppConverter::EncodeL(const TDesC& aText, TBool aTextTobeTruncated) const

	{

	const TUid KUidTextToEtextNoTrim={0x10281B4C};

	// Make a copy of aText and truncate if necessary.

	TPtr truncText(const_cast<TUint16*>(aText.Ptr()),aText.Length());

	if(aTextTobeTruncated)

		truncText.SetLength(aText.Length()>KCntMaxTextFieldLength ? KCntMaxTextFieldLength : aText.Length());

	else

		truncText.SetLength(aText.Length());

	HBufC8* text=HBufC8::NewLC(truncText.Length()*2);

	TPtr8 ptr = text->Des();

	TInt i;

	for (i=0; i < truncText.Length(); i++)

		{

		ptr.Append(truncText[i] & 0x00FF);

		ptr.Append((truncText[i] >> 8) & 0x00FF);

		}

	CCnaConverterList* convList=CCnaConverterList::NewLC(); 

	CConverterBase* conv = convList->NewConverterL(KUidTextToEtextNoTrim); 

	if (!conv)