#include <e32test.h>

#include <cntdb.h>

#include <cntitem.h>

#include <cntfield.h>

#include <cntfldst.h>

#include <phbksync.h>

// include templates for CleanupResetAndDestroyPushL(T)

#include "cntviewprivate.h"

#include "cntsyncchecker.h"

_LIT(KTestName,"CContactICCEntry tests with multiple phonebooks");

_LIT(KDatabaseFileName,"C:T_ICCMULTIPLEPHONEBOOK");

_LIT(KGivenEditName,"edited name");

_LIT(KIccName,"icc entry name");

_LIT(KNonIccName,"non-icc name");

_LIT(KPluginName,"phone book synchronizer Implementation");

_LIT(KTestPluginName,"Test phone book synchronizer Implementation");

CCntTest* CntTest=NULL;

LOCAL_D RTest test(KTestName);

LOCAL_D CContactSyncChecker* syncChecker;

//===============================================================================================

// SETUP & UTILITIES

//===============================================================================================

class TFieldEntry

	{

	public:

		TFieldEntry(TFieldType aField);

		TFieldEntry(TFieldType aField,TUid aFieldType);

	public:

		TFieldType iField;

		TUid iFieldType;

	};

TFieldEntry::TFieldEntry(TFieldType aField)

:iField(aField)

,iFieldType(KUidIccPhonebookNotFound)

	{}

TFieldEntry::TFieldEntry(TFieldType aField,TUid aFieldType)

:iField(aField)

,iFieldType(aFieldType)

	{}

/**

 * Create a new template and add it to the database

 * @param aDb Contact database

 * @param aTemplateName Name for the template

 * @param aFieldSet Array of fields which should are added to the template

 * @return TContactItemId Id of the newly created template

 */

TContactItemId CreatePhonebookTemplateL(CContactDatabase& aDb, const TDesC& aTemplateName, RArray<TFieldEntry>& aFieldSet)

	{

	CContactItem* temp = aDb.CreateContactCardTemplateLC(aTemplateName);

	TContactItemId templateId = temp->Id();

	CleanupStack::PopAndDestroy(temp);

	temp=NULL;

	//Remove all the unnecessary fields

	temp = aDb.OpenContactLX(templateId);

	CleanupStack::PushL(temp);	

	const TInt fieldCount = temp->CardFields().Count();

	for(TInt i=fieldCount-1;i>=0;i--)

		temp->RemoveField(i);

	// Add each of the required fields to the template

	for (TInt j=0; j<aFieldSet.Count(); ++j)

		{

		TFieldEntry fieldEntry=aFieldSet[j];

		CContactItemField* field = CContactItemField::NewLC(KStorageTypeText,fieldEntry.iField);

		if (fieldEntry.iFieldType!=KNullUid)

			field->AddFieldTypeL(fieldEntry.iFieldType);

		temp->AddFieldL(*field);

		CleanupStack::Pop(field);

		}

	aDb.CommitContactL(*temp);

	CleanupStack::PopAndDestroy(2); // temp, close template

	return templateId;

	}

/**

 * Return an array of fields for the phonebook specified

 * @param aPhonebookUid The phonebook uid

 * @return RArray<TFieldEntry> Field set for this specific phonebook.  Any contact item

 * which belongs to this phonebook should contain these fields

 */

RArray<TFieldEntry> fieldSetForPhonebook(TUid aPhonebookUid)

	{

	RArray<TFieldEntry> entries;

	entries.Append(TFieldEntry(KUidContactFieldFamilyName));

	entries.Append(TFieldEntry(KUidContactFieldGivenName));

	entries.Append(TFieldEntry(KUidContactFieldPhoneNumber,KUidContactFieldVCardMapHOME));

	entries.Append(TFieldEntry(KUidContactFieldICCPhonebook));

	if (aPhonebookUid==KUidUsimAppAdnPhonebook)

		{

		entries.Append(TFieldEntry(KUidContactFieldEMail,KUidContactFieldVCardMapHOME));

		entries.Append(TFieldEntry(KUidContactFieldEMail,KUidContactFieldVCardMapWORK));

		entries.Append(TFieldEntry(KUidContactFieldPhoneNumber,KUidContactFieldVCardMapHOME));

		entries.Append(TFieldEntry(KUidContactFieldPhoneNumber,KUidContactFieldVCardMapWORK));

		entries.Append(TFieldEntry(KUidContactFieldPhoneNumber,KUidContactFieldVCardMapCELL));

		entries.Append(TFieldEntry(KUidContactFieldPhoneNumber,KUidContactFieldVCardMapPAGER));

		}

	return entries;

	}

void SetUpIccPhonebooksL(CContactDatabase& aDb)

	{

	test.Next(_L("Set up phonebooks"));

	RArray<TUid>	phbkList;

	CleanupClosePushL(phbkList);

	phbkList.AppendL(KUidIccGlobalAdnPhonebook);

	phbkList.AppendL(KUidIccGlobalSdnPhonebook);

	phbkList.AppendL(KUidIccGlobalLndPhonebook);

	phbkList.AppendL(KUidUsimAppAdnPhonebook);

	// tell phonebook sync simulator what phonebooks to use

	test(syncChecker->SetPhonebookListL(phbkList) == KErrNone);

	// simulate synchronisation - includes creating/finding template & group

	// also defaults all validate responses to KErrNone

	test(syncChecker->SynchroniseIccAllPhonebooksL(aDb, KErrNone, KErrNone) == KErrNone);

	CleanupStack::PopAndDestroy(); // phbkList

	}

/**

 * Check the content of the phonebook field in the contact item

 * @param aContactItem Contact item

 * @param aPhonebookUid The phonebook uid

 * @param aFieldIsSet EFalse if the phonebook field should not contain a value, else ETrue

 */

void CheckPhonebookField(CContactItem& aContactItem,TUid aPhonebookUid,TBool aFieldIsSet)

	{

	const CContactItemFieldSet& fieldset = aContactItem.CardFields();

	const TInt pos = fieldset.Find(KUidContactFieldICCPhonebook);

	test(pos!=KErrNotFound);

	TPtrC phonebookField=fieldset[pos].TextStorage()->Text();

	if(aFieldIsSet)

		{

		TLex input(phonebookField);

		TInt phonebookFieldVal;

		/*TInt ignore  = */ input.Val(phonebookFieldVal);

		TUid phonebookFieldUid;

		phonebookFieldUid.iUid=phonebookFieldVal;

		test(phonebookFieldUid==aPhonebookUid);

		}

	else

		test(phonebookField==KNullDesC);

	}

/**

 * Verify that the template id returned by CContactDatabase::ICCTemplateIdL is the

 * same as that returned directly from the plugin

 * @param aDb Contact database

 */

void VerifyPhonebookTemplateIdsL(CContactDatabase& aDb)

	{

	test.Next(_L("Verify template ids"));

	syncChecker->ResetMethodCallCountsL();

	test(aDb.ICCTemplateIdL() == syncChecker->ICCTemplateIdL(KUidIccGlobalAdnPhonebook));

	test(aDb.ICCTemplateIdL(KUidIccGlobalAdnPhonebook) == syncChecker->ICCTemplateIdL(KUidIccGlobalAdnPhonebook));

	test(aDb.ICCTemplateIdL(KUidIccGlobalSdnPhonebook) == syncChecker->ICCTemplateIdL(KUidIccGlobalSdnPhonebook));

	test(aDb.ICCTemplateIdL(KUidIccGlobalLndPhonebook) == syncChecker->ICCTemplateIdL(KUidIccGlobalLndPhonebook));

	test(aDb.ICCTemplateIdL(KUidUsimAppAdnPhonebook) == syncChecker->ICCTemplateIdL(KUidUsimAppAdnPhonebook));

	test(aDb.ICCTemplateIdL(KNullUid) == KNullContactId);

	test(syncChecker->ValidateMethodCallCountL() == 6);

	}

/**

 * Set the name field of the contact with id aId to contain the name aName

 * @param aDb Contact database

 * @param aId Contact item id

 * @param aName A name

 */

void SetNameField(CContactDatabase& aDb,TContactItemId aId,const TDesC& aName)

	{

	syncChecker->ResetMethodCallCountsL();

	CContactItem* item = aDb.OpenContactLX(aId);

	CleanupStack::PushL(item);

	if (item->Type() == KUidContactICCEntry)

		{

		test(syncChecker->ValidateMethodCallCountL() == 2);

		}

	else

		{

		test(syncChecker->ValidateMethodCallCountL() == 0);

		}

	CContactItemFieldSet& fieldset = item->CardFields();

	TInt pos = fieldset.Find(KUidContactFieldFamilyName);

	test(pos!=KErrNotFound);

	CContactItemField& field = fieldset[pos];

	CContactTextField* textfield = field.TextStorage();

	textfield->SetTextL(aName);

	syncChecker->ResetMethodCallCountsL();

	aDb.CommitContactL(*item);

	if (item->Type() == KUidContactICCEntry)

		{

		test(syncChecker->ValidateMethodCallCountL() == 2);

		}

	else

		{

		test(syncChecker->ValidateMethodCallCountL() == 0);

		}

	CleanupStack::PopAndDestroy(2); // item, lock record

	}

/**

 * Set the phone number field of the contact with id aId to contain the number aNumber

 * @param aDb Contact database

 * @param aId Contact item id

 * @param aNumber A telephone number

 */

void SetPhoneNumberField(CContactDatabase& aDb,TContactItemId aId,const TDesC& aNumber)

	{

	syncChecker->ResetMethodCallCountsL();

	CContactItem* item = aDb.OpenContactLX(aId);

	CleanupStack::PushL(item);

	if (item->Type() == KUidContactICCEntry)

		{

		test(syncChecker->ValidateMethodCallCountL() == 2);

		}

	else

		{

		test(syncChecker->ValidateMethodCallCountL() == 0);

		}

	CContactItemFieldSet& fieldset = item->CardFields();

	TInt pos = fieldset.Find(KUidContactFieldPhoneNumber);

	test(pos!=KErrNotFound);

	CContactItemField& field = fieldset[pos];

	CContactTextField* textfield = field.TextStorage();

	textfield->SetTextL(aNumber);

	syncChecker->ResetMethodCallCountsL();

	aDb.CommitContactL(*item);

	if (item->Type() == KUidContactICCEntry)

		{

		test(syncChecker->ValidateMethodCallCountL() == 2);

		}

	else

		{

		test(syncChecker->ValidateMethodCallCountL() == 0);

		}

	CleanupStack::PopAndDestroy(2); // item, lock record

	}

//===============================================================================================

// ADDING entries

//===============================================================================================

/**

 * Create an entry based on the template for this specific phonebook, and add

 * the entry to the contact database

 * @param aDb Contact database

 * @param aPhonebookUid The phonebook uid

 * @return TContactItemId Id of the newly created icc entry

 */

TContactItemId doAddIccEntryL(CContactDatabase& aDb,TUid aPhonebookUid)

	{

	syncChecker->ResetMethodCallCountsL();

	TContactItemId templateId = aDb.ICCTemplateIdL(aPhonebookUid);

	test(syncChecker->ValidateMethodCallCountL() == 1);

	CContactItem* iccTemplate = aDb.ReadContactLC(templateId);

	CContactICCEntry* entry = CContactICCEntry::NewL(*iccTemplate);

	CleanupStack::PopAndDestroy(iccTemplate);

	CleanupStack::PushL(entry);

	// Add to the database

	CheckPhonebookField(*entry,aPhonebookUid, EFalse);

	syncChecker->ResetMethodCallCountsL();

	TContactItemId id = aDb.AddNewContactL(*entry); 

	test(syncChecker->ValidateMethodCallCountL() == 3);

	CleanupStack::PopAndDestroy(entry);

	test(id!=KNullContactId);

	// Check group membership

	syncChecker->ResetMethodCallCountsL();

	CContactICCEntry* fetchedItem = static_cast<CContactICCEntry*>(aDb.ReadContactL(id));

	test(syncChecker->ValidateMethodCallCountL() == 1);

	CleanupStack::PushL(fetchedItem);	

	const CContactIdArray* owned = fetchedItem->GroupsJoined();

	test(owned!=NULL && owned->Count() == 1);

	test((*owned)[0]==syncChecker->GroupIdL(aPhonebookUid));

	test(fetchedItem->Type() == KUidContactICCEntry);

	// Verify that the phonebook field has been set

	CheckPhonebookField(*fetchedItem,aPhonebookUid, ETrue);

	CleanupStack::PopAndDestroy(fetchedItem);	

	return id;

	}

TContactItemId AddIccEntryL(CContactDatabase& aDb,TUid aPhonebookUid)

	{

	syncChecker->SetValidateWriteResponseL(KErrNone);

	return doAddIccEntryL(aDb, aPhonebookUid);

	}

void UnsuccessfulAddIccEntryL(CContactDatabase& aDb,TUid aPhonebookUid, TInt aReason)

	{

	syncChecker->SetValidateWriteResponseL(aReason);

	TRAPD(err,doAddIccEntryL(aDb, aPhonebookUid));

	test(err==aReason);

	}

void AddEntriesBasedOnEachOfTheTemplatesL(CContactDatabase& aDb)

	{

	test.Next(_L("Test successful adding"));

	TInt numberOfAdnEntries=3;

	TInt numberOfSdnEntries=2;

	TInt numberOfLdnEntries=1;

	TInt numberOfUsimEntries=4;

	TInt iter=0;

	for (iter=0; iter<numberOfAdnEntries; ++iter)

		{

		TContactItemId id=AddIccEntryL(aDb,KUidIccGlobalAdnPhonebook);

		CContactGroup* group=static_cast<CContactGroup*>(aDb.ReadContactLC(syncChecker->GroupIdL(KUidIccGlobalAdnPhonebook)));

		CContactIdArray* entries=group->ItemsContainedLC();

		test(entries->Count() == iter+1);

		CleanupStack::PopAndDestroy(entries);

		test(group->ContainsItem(id));

		CleanupStack::PopAndDestroy(group);

		}

	for (iter=0; iter<numberOfSdnEntries; ++iter)

		{

		TContactItemId id=AddIccEntryL(aDb,KUidIccGlobalSdnPhonebook);

		CContactGroup* group=static_cast<CContactGroup*>(aDb.ReadContactLC(syncChecker->GroupIdL(KUidIccGlobalSdnPhonebook)));

		CContactIdArray* entries=group->ItemsContainedLC();

		test(entries->Count() == iter+1);

		CleanupStack::PopAndDestroy(entries);

		test(group->ContainsItem(id));

		CleanupStack::PopAndDestroy(group);

		}

	for (iter=0; iter<numberOfLdnEntries; ++iter)

		{

		TContactItemId id=AddIccEntryL(aDb, KUidIccGlobalLndPhonebook);

		CContactGroup* group=static_cast<CContactGroup*>(aDb.ReadContactLC(syncChecker->GroupIdL(KUidIccGlobalLndPhonebook)));

		CContactIdArray* entries=group->ItemsContainedLC();

		test(entries->Count() == iter+1);

		CleanupStack::PopAndDestroy(entries);

		test(group->ContainsItem(id));

		CleanupStack::PopAndDestroy(group);

		}

	for (iter=0; iter<numberOfUsimEntries; ++iter)

		{

		TContactItemId id=AddIccEntryL(aDb,KUidUsimAppAdnPhonebook);

		CContactGroup* group=static_cast<CContactGroup*>(aDb.ReadContactLC(syncChecker->GroupIdL(KUidUsimAppAdnPhonebook)));

		CContactIdArray* entries=group->ItemsContainedLC();

		test(entries->Count() == iter+1);

		CleanupStack::PopAndDestroy(entries);

		test(group->ContainsItem(id));

		CleanupStack::PopAndDestroy(group);

		}

	// Add an ICC entry based on the system template, not one of the ICC templates

	TContactItemId templateId=aDb.TemplateId();

	CContactItem* systemTemplate = aDb.ReadContactLC(templateId);

	CContactICCEntry* entry = CContactICCEntry::NewL(*systemTemplate);

	CleanupStack::PopAndDestroy(systemTemplate);

	CleanupStack::PushL(entry);

	syncChecker->ResetMethodCallCountsL();

	TContactItemId id = aDb.AddNewContactL(*entry); 

	test(syncChecker->ValidateMethodCallCountL() == 3);

	syncChecker->ResetMethodCallCountsL();

	CContactItem* item=aDb.ReadContactLC(id);

	test(syncChecker->ValidateMethodCallCountL() == 1);

	// check the entry hasn't been added to any group

	CContactIdArray* array=static_cast<CContactICCEntry*>(item)->GroupsJoinedLC();

	test(array->Count() == 0);

	CleanupStack::PopAndDestroy(3); // array, close item, item

	}

void TestUnsuccessfulAddL(CContactDatabase& aDb)

	{

	// Test adding entries to each of the phonebooks when the ICC is locked, unaccessible or corrupt

	test.Next(_L("Test unsuccessful adding"));

	UnsuccessfulAddIccEntryL(aDb,KUidIccGlobalAdnPhonebook,KErrLocked);

	UnsuccessfulAddIccEntryL(aDb,KUidIccGlobalAdnPhonebook,KErrAccessDenied);

	UnsuccessfulAddIccEntryL(aDb,KUidIccGlobalAdnPhonebook,KErrCorrupt);

	UnsuccessfulAddIccEntryL(aDb,KUidIccGlobalSdnPhonebook,KErrLocked);

	UnsuccessfulAddIccEntryL(aDb,KUidIccGlobalSdnPhonebook,KErrAccessDenied);

	UnsuccessfulAddIccEntryL(aDb,KUidIccGlobalSdnPhonebook,KErrCorrupt);

	UnsuccessfulAddIccEntryL(aDb,KUidIccGlobalLndPhonebook,KErrLocked);

	UnsuccessfulAddIccEntryL(aDb,KUidIccGlobalLndPhonebook,KErrAccessDenied);

	UnsuccessfulAddIccEntryL(aDb,KUidIccGlobalLndPhonebook,KErrCorrupt);

	UnsuccessfulAddIccEntryL(aDb,KUidUsimAppAdnPhonebook,KErrLocked);

	UnsuccessfulAddIccEntryL(aDb,KUidUsimAppAdnPhonebook,KErrAccessDenied);

	UnsuccessfulAddIccEntryL(aDb,KUidUsimAppAdnPhonebook,KErrCorrupt);

	}

/** 

 * Verify that adding contact cards doesn't call the synchroniser interface

 * @param aDb Contact database

 */

TContactItemId AddContactCardL(CContactDatabase& aDb)

	{

	_LIT(KTemplateName,"contact card template");

	RArray<TFieldEntry> entries=fieldSetForPhonebook(KUidIccGlobalAdnPhonebook);

	TContactItemId templateId=CreatePhonebookTemplateL(aDb,KTemplateName,entries);

	entries.Close();

	CContactItem* iccTemplate = aDb.ReadContactLC(templateId);

	CContactCard* card = CContactCard::NewLC(iccTemplate);

	syncChecker->ResetMethodCallCountsL();

	TContactItemId id=aDb.AddNewContactL(*card);

	test(syncChecker->ValidateMethodCallCountL() == 0);

	CleanupStack::PopAndDestroy(2,iccTemplate);

	return id;

	}

//===============================================================================================

// DELETING entries

//===============================================================================================

/**

 * Verify that the synchroniser is called when deleting an icc entry, and that the 

 * deletion of an icc entry fails if the icc is locked.

 * @param aDb Contact database

 */

void TestDeleteL(CContactDatabase& aDb)

	{

	test.Next(_L("Test delete when ICC locked"));

	syncChecker->SetDeleteContactResponseL(KErrLocked);

	TContactItemId iccId=AddIccEntryL(aDb,KUidIccGlobalAdnPhonebook);

	syncChecker->ResetMethodCallCountsL();

	TRAPD(err,aDb.DeleteContactL(iccId));

	test(err==KErrLocked);

	test(syncChecker->ValidateMethodCallCountL() == 2);

	syncChecker->ResetMethodCallCountsL();

	CContactItem* item=aDb.ReadContactLC(iccId);

	test(syncChecker->ValidateMethodCallCountL() == 1);

	test(item!=NULL);

	CleanupStack::PopAndDestroy(item);

	item=NULL;

	test.Next(_L("Test successful delete of non-icc entry when ICC locked"));

	TContactItemId nonIccId=AddContactCardL(aDb);

	syncChecker->ResetMethodCallCountsL();

	TRAP(err,aDb.DeleteContactL(nonIccId));

	test(err==KErrNone);

	test(syncChecker->ValidateMethodCallCountL() == 0);

	test.Next(_L("Test successful delete"));

	syncChecker->SetDeleteContactResponseL(KErrNone);

	syncChecker->ResetMethodCallCountsL();

	TRAP(err,aDb.DeleteContactL(iccId));

	test(syncChecker->ValidateMethodCallCountL() == 2);

	test(err==KErrNone);

	syncChecker->ResetMethodCallCountsL();

	TRAP(err,aDb.ReadContactLC(iccId));

	test(syncChecker->ValidateMethodCallCountL() == 0);

	test(err==KErrNotFound);

	}

//===============================================================================================

// READING entries

//===============================================================================================

void TestReadMinimalContactL(CContactDatabase& aDb, TContactItemId aIccId, TContactItemId aNonIccId)

	{

	test.Next(_L("Test ReadMinimalContactL"));

	// Successful read of icc entry

	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);

	syncChecker->ResetMethodCallCountsL();

	CContactItem* item=aDb.ReadMinimalContactLC(aIccId);

	test(syncChecker->ValidateMethodCallCountL() == 1);

	test(item!=NULL);

	CleanupStack::PopAndDestroy(item);

	item=NULL;

	// Unsuccessful read of icc entry because icc locked

	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrAccessDenied);

	syncChecker->ResetMethodCallCountsL();

	TRAPD(err,item=aDb.ReadMinimalContactLC(aIccId));

	test(syncChecker->ValidateMethodCallCountL() == 1);

	test(item==NULL);

	test(err==KErrAccessDenied);

	// successful read of non-icc entry, even though icc locked

	syncChecker->ResetMethodCallCountsL();

	item=aDb.ReadMinimalContactLC(aNonIccId);

	test(syncChecker->ValidateMethodCallCountL() == 0);

	test(item!=NULL);

	CleanupStack::PopAndDestroy(item);

	item=NULL;

	}

void TestReadContactL(CContactDatabase& aDb, TContactItemId aIccId, TContactItemId aNonIccId)

	{

	test.Next(_L("Test ReadContactL"));

	// Successful read of icc entry

	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);

	syncChecker->ResetMethodCallCountsL();

	test(syncChecker->ValidateMethodCallCountL() == 0);	

	CContactItem* item=aDb.ReadContactLC(aIccId);

	test(syncChecker->ValidateMethodCallCountL() == 1);

	test(item!=NULL);

	CleanupStack::PopAndDestroy(item);

	item=NULL;

	// Unsuccessful read of icc entry because icc locked

	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrAccessDenied);