// Copyright (c) 1997-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 <cntvcard.h>

#include "cntvcardutils.h"

// System includes

#include <badesca.h>

#include <s32std.h>

#include <s32mem.h>

#include <ecom/implementationproxy.h>

// User includes

#include "CNTPROF.H"

#include <cntfldst.h>

#include <cntfield.h>

#include <cntdef.h>

#include <cntitem.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "cntconvertercallback.h"

#endif

/** 

 * Imports one or more vCards from a read stream. The vCards are converted 

 * into contact items, and added to the database. If at least one contact

 * item was successfully imported, aImportSuccessful is set to ETrue. 

 * 

 * @param aDb Contacts database

 * @param aReadStream The stream to read from.

 * @param aImportSuccessful On return, ETrue if at least one contact was successfully imported. EFalse if not

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

 * @param aImportSingleContact Import a single vCard entity

 * @return Array of CContactItem objects

 */

CArrayPtr<CContactItem>* CContactVCardConverter::ImportL(CContactDatabase& aDb,RReadStream& aReadStream,TBool& aImportSuccessful,TInt aOption,TBool aImportSingleContact)

	{

__START_PROFILE(23);

	TBool increaseAccessCount=aOption & (EIncreaseAccessCount);

	TBool decreaseAccessCount=aOption & (EDecreaseAccessCount);

	aImportSuccessful=EFalse;	

	CVCardToContactsAppConverter* converter=new(ELeave)	CVCardToContactsAppConverter;

	CleanupStack::PushL(converter);

	CArrayPtr<CContactItem>* contactItems=new(ELeave) CArrayPtrFlat<CContactItem>(4);

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

	TInt err=KErrNone;

	if (!aImportSingleContact)

		{

		aDb.DatabaseBeginLC(EFalse);

		}

	while (err!=KErrEof)

		{

		CParserVCard* vCard= CParserVCard::NewL();

		CleanupStack::PushL(vCard);

__START_PROFILE(20);

		TRAP(err,vCard->InternalizeL(aReadStream));

__END_PROFILE(20);

		if ((err != KErrNotFound) && (err != KErrEof))

	  		{

			User::LeaveIfError(err);

				TContactItemId pos = IsVCardMergeNeededL(*converter, *vCard, aDb, aOption);

				//Check if we have been asked to replaced rather than merge the

				//contact item.		

				TContactItemId posId = KErrNotFound;

				if ((aOption & EReplaceIfExists) && (pos != KErrNotFound))

					{

					posId = pos;

					pos = KErrNotFound;						

					}

				if (pos == KErrNotFound)

					{

					//this is a vCard previously exported but now deleted from the database

					//treat as a new card

					//or an existing contact item which is to be

					//updated (replaced) with the given vCard.

					doImportL(*converter, *vCard, aDb, aOption, increaseAccessCount, decreaseAccessCount, aImportSuccessful, contactItems, !aImportSingleContact, posId);

					}

				else

					{

					//this is a existing contact to update

					CContactItem* item=aDb.OpenContactLX(pos);

					CleanupStack::PushL(item);

					ModifyAccessCountL(*item, increaseAccessCount, decreaseAccessCount);

					TUid type = item->Type();

					if (type != KUidContactCard && type != KUidContactOwnCard)

						{

						User::Leave(KErrNotFound);

						}

					CArrayPtr<CParserProperty>* agentPropertyList = NULL;

					agentPropertyList = vCard->PropertyL(KVersitTokenAGENT, TUid::Uid(KVCardPropertyAgentUid));

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

					if(agentPropertyList && agentPropertyList->Count())

						{

						//Add agents to contact item and if needed, merge agentcards with existing contacts

						HandleAgentsInVCardL(*converter, agentPropertyList, *item, aDb, aOption, increaseAccessCount, decreaseAccessCount, contactItems,ETrue);

						}		

					CleanupStack::PopAndDestroy(agentPropertyList);

					TBool deleteItem = converter->MergeVCardWithContactItemL(*item, *vCard, CVCardToContactsAppConverter::EPreserveAllProperties, aOption);

					aDb.doCommitContactL(*item, ETrue, ETrue);  

					if (deleteItem)

						{

						CleanupStack::PopAndDestroy(2); // item, item close

						aDb.doDeleteContactL(pos, ETrue, ETrue, decreaseAccessCount);

						}

					else

						{

						contactItems->AppendL(item);

						CleanupStack::Pop(); // item

						CleanupStack::PopAndDestroy(); // item close

						}

					aImportSuccessful = ETrue;

 				}

			}	

		CleanupStack::PopAndDestroy();	// vCard

		if (aImportSingleContact)

			{

			break;

			}

		}

	if (!aImportSingleContact)

		{

		aDb.DatabaseCommitLP(EFalse);

		}

	CleanupStack::Pop();	// contactItems

	CleanupStack::PopAndDestroy(); //converter

__END_PROFILE(23);

	return contactItems;

	}

/** 

 * Import a vCard object

 * 

 * @param aConverter Import converter

 * @param aVCard vCard object to import

 * @param aDb Contacts database reference

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

 * @param aIncAccessCount Increment the access count of contact items imported

 * @param aDecAccessCount Decrement the access count of contact items imported

 * @param aImportSuccessful vCard object was imported successfully

 * @param aContactItems Array of imported contact items

 * @param aIdForUpdate  contact ID which is to be updated / replaced with the imported vCrad.

 */

void CContactVCardConverter::doImportL(CVCardToContactsAppConverter& aConverter, CParserVCard& aVCard, CContactDatabase& aDb, TInt aOption, TBool aIncAccessCount, TBool aDecAccessCount, TBool& aImportSuccessful, CArrayPtr<CContactItem>* aContactItems, TBool aIsInTransaction, TContactItemId aIdForUpdate)

	{

	CArrayPtr<CParserProperty>* agentPropertyList = NULL;

	agentPropertyList = aVCard.PropertyL(KVersitTokenAGENT, TUid::Uid(KVCardPropertyAgentUid));

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

	CContactItem* mainItem = aConverter.GetVCardAsContactItemLC(aVCard, CVCardToContactsAppConverter::EPreserveAllProperties, aOption);

	if (agentPropertyList && agentPropertyList->Count())

		{

		//Add agents to contact item and if needed, merge agentcards with existing contacts

		HandleAgentsInVCardL(aConverter, agentPropertyList, *mainItem, aDb, aOption, aIncAccessCount, aDecAccessCount, aContactItems, EFalse);

		}

	if	(mainItem->CardFields().Count()) // checks vcard is not empty

		{

		ModifyAccessCountL(*mainItem, aIncAccessCount, aDecAccessCount);

		if	(aOption & ENullTemplateId)

			{

			mainItem->SetTemplateRefId(KNullContactId);

			}

		else

			{

			mainItem->SetTemplateRefId(KGoldenTemplateId);

			}

		//Check if we have been asked to replace (update) rather than add 

		//the contact item.

		if ((aOption & EReplaceIfExists) && (aIdForUpdate != KErrNotFound))

			{

			CContactItem* oldItem;

			oldItem = aDb.OpenContactL(aIdForUpdate);

			CleanupStack::PushL(oldItem);								

			CContactItemFieldSet& fieldSet = oldItem->CardFields();			

			fieldSet.Reset();			

			aDb.CommitContactL(*oldItem);

			CleanupStack::PopAndDestroy(oldItem);

			CContactItem* updateItem = NULL;

			updateItem = aDb.UpdateContactLC(aIdForUpdate, mainItem);

			aContactItems->AppendL(updateItem); 

			CleanupStack::Pop(updateItem);

			CleanupStack::PopAndDestroy(mainItem);		

			}

		else

			{			

			aDb.doAddNewContactL(*mainItem, EFalse, aIsInTransaction);

			aContactItems->AppendL(mainItem);

			CleanupStack::Pop(mainItem);

			}

		aImportSuccessful = ETrue;

		}

	else

		{

		// Just cleanup

		CleanupStack::PopAndDestroy(mainItem);

		}

	CleanupStack::PopAndDestroy(agentPropertyList);

	}

/** 

 * Export a contact as vCard.

 * 

 * @param aDb Contact database

 * @param aSelectedContactIds Array of contact items IDs to export

 * @param aWriteStream Stream to externalize vCard data to 

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

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

 * @param aExportPrivateFields Specify whether private fields are included

 * @param aCommitNumber Number of contacts to be exported before commit of database

 */

void CContactVCardConverter::ExportL(CContactDatabase& aDb,const CContactIdArray& aSelectedContactIds,RWriteStream& aWriteStream,TInt aOption,const Versit::TVersitCharSet aCharSet, TBool aExportPrivateFields, TInt aCommitNumber=10)

	{

	const TBool increaseAccessCount=aOption & (EIncreaseAccessCount);

	const TBool decreaseAccessCount=aOption & (EDecreaseAccessCount);

	const TBool accessCountChanges=decreaseAccessCount || increaseAccessCount;

	CContactsAppToVCardConverter* converter = new(ELeave)CContactsAppToVCardConverter(aDb.MachineId(), aCharSet, EVCard21);

	CleanupStack::PushL(converter);

	const TInt count=aSelectedContactIds.Count();

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

		{

		CContactItem* contactItem=NULL;

		TContactItemId id=aSelectedContactIds[ii];

		if (accessCountChanges)

			{

			if (ii % aCommitNumber == 0)	// 1st item of N

				{

				aDb.DatabaseBeginLC(EFalse);	

				}

			contactItem=aDb.OpenContactLX(id);

			CleanupStack::PushL(contactItem);

			}

		else

			{

			contactItem=aDb.ReadContactLC(id,*aDb.AllFieldsView());

			}

		CContactItemFieldSet& fields=contactItem->CardFields(); 

		TInt agentPos = KContactFieldSetSearchAll; 

		CContactItem* agentItem = NULL;

		CArrayPtr<CContactItem>* agentItemArray = new(ELeave) CArrayPtrFlat<CContactItem>(4);

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

		while(1)

			{

			agentPos = fields.FindNext(KUidContactFieldVCardMapAGENT, agentPos);

			TContactItemId agentId;

			if (agentPos != KErrNotFound)

				{

		  		agentId = fields[agentPos].AgentStorage()->Value();		

			  	TRAPD(err, agentItem = aDb.ReadContactL(agentId, *aDb.AllFieldsView()));

				if(err != KErrNotFound) 

	 				{

	 				User::LeaveIfError(err);

					agentItemArray->AppendL(agentItem);

				  	}

				++agentPos;

				agentItem = NULL;

				}

			else

				{

				break;

				}

		}//while

		CParserVCard* vCard=converter->GetContactItemAsVCardL(contactItem, agentItemArray, aOption, aExportPrivateFields);

 		CleanupStack::PushL(vCard);

		vCard->SetDefaultCharSet(aCharSet);

		vCard->ExternalizeL(aWriteStream); 

		CleanupStack::PopAndDestroy(vCard);

		CleanupStack::PopAndDestroy(agentItemArray);

		if (accessCountChanges)

			{

			if (decreaseAccessCount)

				{

				contactItem->DecAccessCount();

				}

			if (increaseAccessCount)

				{

				contactItem->IncAccessCount();

				}

			aDb.doCommitContactL(*contactItem,ETrue,EFalse);	// commit every 10 by default

			CleanupStack::PopAndDestroy(); // contactItem

			CleanupStack::PopAndDestroy(); // contact close from OpenContactLX

			// Nth item or last item

			if (((ii + 1) % aCommitNumber == 0) || ii == (count - 1))

				{

				aDb.DatabaseCommitLP(EFalse);

				}

			}

		else	// access count does not change

			{

			CleanupStack::PopAndDestroy(); // contactItem

			}

		}

	CleanupStack::PopAndDestroy(converter); 

	}

TBool CContactVCardConverter::ContainsExportableData(const TDesC& aText)

/**  

 * Two different export rules:

 * 

 * RULE 1: Single property values, e.g. TEL, LABEL, FN, NOTE etc etc

 * For this type of property value, whitespace is not exported to the PIM, i.e this property

 * value should not be sent to the PIM for merging.

 * 

 * RULE 2: Multi property values, e.g. ADR, N, ORG etc etc

 * 

 * a) NULL means that the field is not supported by the device. It does NOT mean that the

 * field should be deleted from the PIM. Therefore, when a NULL value is sent by the device to the PC

 * the existing PC-PIM contact field should be preserved.

 * 

 * b) a SINGLE SPACE means that the field is supported by the device, but currently has an empty value (i.e.

 * the field has been deleted or is currently empty).

 * 

 * =====> This implementation only current obeys RULE1.

 * 

 * @param aText The text to be analyzed

 */

	{

	return ContainsData(aText);

	}

TBool CContactVCardConverter::ContainsImportableData(const TDesC& aText, TVersitPropertyType aType, TCntVCardImportType aImportType)

/**

 * Two different import rules:

 * 

 * RULE 1: Single property values, e.g. TEL, LABEL, FN, NOTE etc etc

 * For this type of property value, a NULL value (i.e aText.Length() == 0) means that

 * the specified field should be deleted from the contact card. Any whitespace will be

 * ignored and not imported into the Contacts Database.

 * 

 * RULE 2: Multi property values, e.g. ADR, N, ORG etc etc

 * PC-based PIM's have varying support for the different sub-fields within a multi-property

 * object. Therefore, in a multi-property value object, the following semantics are observed

 * 

 * a) NULL means that the field is not supported by the PIM software. It does NOT mean that the

 * field should be deleted. Therefore, when a NULL value is sent by the PC Sync Engine to the

 * device no changes should be made to the corresponding field in the contact card.

 * 

 * b) a SINGLE SPACE means that the field is supported by the PC PIM, but has an empty value (i.e.

 * the field has been deleted or is currently empty).

 * 

 * A further complication is that during a non-merge sync, its entirely possible for the PC to

 * send vCard data which is effectively empty. One such example is TimeIS data extracted from

 * MS Outlook which then sent to the device. In this case, even if the PIM shows an address

 * as being empty, TimeIS sync drivers still send this empty address, e.g.:

 * 

 * ADR;HOME: ;; ; ; ; ; 

 * 

 * In this instance, we must ensure that we do not import a completely empty property. Therefore

 * the SPACE/NULL syntax is only used explicitly during a MERGE operation. An INITIAL SYNC

 * doesn't need to understand the SPACE/NULL syntax.

 * 

 * =====> This implementation obeys both rules completely.

 * @param aText The text to be analyzed.

 * @param aType Specify if the property is a single or multi-fielded type

 * @param aImportType Specify if this is the first time the card is being imported or if its a merge.

*/

	{

	TBool validDataForImport = EFalse;

	const TInt length = aText.Length();

	if	(aType == EPropertyValueComposite)

		{

		if	(aImportType == ECntVCardImportTypeFirstSync)

			{

			if	(!length || (length == 1 && aText[0] == KContactVCardSpaceCharacter))

				{

				// We do not import either

				//

				// - empty (but supported) PIM fields 

				// - empty (non supported) PIM fields

				//

				// during initial sync since these would lead to fields in the contact card

				// which contain spaces.

				validDataForImport = EFalse;

				}

			else

				{

				// If its non-whitespace, we'll allow it for import

				validDataForImport = ContainsData(aText);

				}

			}

		else if (aImportType == ECntVCardImportTypeMerge)

			{

			if	(!length)

				{

				// Don't process (i.e. delete) fields which are not supported by the PC PIM.

				validDataForImport = EFalse;

				}

			else if	(length == 1 && aText[0] == KContactVCardSpaceCharacter)

				{

				// This field is empty in the PIM and therefore we must 'import it' (which in fact,

				// means we must delete the corresponding device-side field).

				validDataForImport = ETrue;

				}

			else 

				{

				// Otherwise check each character to weed out the whitespace

				validDataForImport = ContainsData(aText);

				}

			}

		else

			Panic(ECntVPanicInvalidImportType);

		}

	else if (aType == EPropertyValueSingle)

		{

		// We must import (process) NULL values, since they effectively mean 'DELETE'

		// We do not import fields containing only whitespace

		validDataForImport = (!length || ContainsData(aText));

		}

	return validDataForImport;

	}

TBool CContactVCardConverter::ContainsData(const TDesC& aText)

/**

 * Determine if the text contains any data that can be imported

 * @param aText The text to be analyzed.

*/

	{

	const TInt length = aText.Length();

	TInt whiteSpaceCount = 0;

	TChar character;

	for(TInt i=0; i<length; i++)

		{

		// If the character is whitespace, then check the next character until

		// all characters have been reached. If its not-whitespace, then this field

		// contains data which can be exported.

		character = aText[i];

		if	(character.IsSpace())

			{

			++whiteSpaceCount;

			}

		else

			{

			return ETrue;

			}

		}

	return (whiteSpaceCount < length);

	}

CContactVCardConverter* CContactVCardConverter::NewL()

	{

	return new(ELeave) CContactVCardConverter();

	}

// Export the implementation collection function

const TImplementationProxy ImplementationTable[] = 

    {

    IMPLEMENTATION_PROXY_ENTRY(0x102035F9, 	CContactVCardConverter::NewL),

    IMPLEMENTATION_PROXY_ENTRY(0xA00015C1, 	CPBAPContactVCardConverter::NewL)

    };

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

    {

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return ImplementationTable;

    }

void CPBAPContactVCardConverter::ExportL(CContactDatabase& aDb, const CContactIdArray& aSelectedContactIds, RWriteStream& aWriteStream, TInt aOption, const Versit::TVersitCharSet aCharSet, TBool aExportPrivateFields, TInt /*aCommitNumber = 10*/)

	{

	CContactsAppToVCardConverter* converter = new(ELeave)CContactsAppToVCardConverter(aDb.MachineId(), aCharSet, GetVersion());

	CleanupStack::PushL(converter);

	const TInt count = aSelectedContactIds.Count();

	converter->SetFilter(PrepareFilterAndOption(aOption));

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

		{

		CContactItem* contactItem = NULL;

		TContactItemId id = aSelectedContactIds[ii];

		contactItem = aDb.ReadContactLC(id, *aDb.AllFieldsView());

		CParserVCard* vCard = converter->GetContactItemAsVCardL(contactItem, NULL, aOption, aExportPrivateFields);

 		CleanupStack::PushL(vCard);

		vCard->SetDefaultCharSet(aCharSet);

		//Intra-Contact Properties start

		MConverterCallBack* clientCallback = GetCallback();

		if(clientCallback)

			{

			CArrayPtr<CParserProperty>* intraPropertyList = NULL;

			intraPropertyList = new(ELeave) CArrayPtrFlat<CParserProperty>(5);

			CleanupStack::PushL(TCleanupItem(CVersitParser::ResetAndDestroyArrayOfProperties, intraPropertyList));