/**

 * Constructor

 */

CPrepareDataTestStep::CPrepareDataTestStep()

	{

	// Mandatory call to base class method to set up the human readable name for logging.

	SetTestStepName(KPrepareDataTestStep);

	}

/**

 * Destructor

 */

CPrepareDataTestStep::~CPrepareDataTestStep()

	{

	iListOfContactItemsInDatabase.Close();

	}

/**

 * Setup the environment required for test, install schedular in the current thread

 * Opens the relevant contacts database file

 */

TVerdict CPrepareDataTestStep::doTestStepPreambleL()

	{

 	CTestContactViewDatabaseUtilitiesStep::doTestStepPreambleL();

	return TestStepResult();

	}

/**

 * Cleanup function for the test step

 */

TVerdict CPrepareDataTestStep::doTestStepPostambleL()

	{

 	CTestContactViewDatabaseUtilitiesStep::doTestStepPostambleL();

	return TestStepResult();

	}

/**

Base class pure virtual.

* @return EPass or EFail indicating the result of the test step.

*/

TVerdict CPrepareDataTestStep::doTestStepL()

	{

	ImportContactsL();

	AddContactsInDatabaseL();

	IterateThroAllSortOrderSectionsAndUpdateContactsInDatabaseL();

	IterateThroAllFilterViewsSectionsAndUpdateL();

	IterateThroAllMatchingStringSectionsAndUpdateL();

	AddGroupsInDatabaseL();

	IterateThroAllGroupSectionsAndUpdateL();

	UpdateContactToSpecificStringL();

	CloseDatabaseL();

	CopyDatabaseL();

	return TestStepResult();

	}

/**

* Import Contact entries

*/

void CPrepareDataTestStep::ImportContactsL()

	{

	ViewUtilityReference().ImportContactsL();

	}

/**

 * Here we are trying add blank contact items in the database

 * Say some 2000 thousand contacts are added to the database

 */

void CPrepareDataTestStep::AddContactsInDatabaseL()

	{

	_LIT(KNumOfContacts, "numofcontacts");

	TInt numOfContacts = 0;

	GetIntFromConfig(ConfigSection(), KNumOfContacts, numOfContacts);

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

		{

		CContactCard* contactCard = CContactCard::NewL();

		CleanupStack::PushL(contactCard);

		TContactItemId contactId = DatabaseReference().AddNewContactL(*contactCard);

		CleanupStack::PopAndDestroy(contactCard);

		iListOfContactItemsInDatabase.AppendL(contactId);

		DatabaseReference().CloseContactL(contactId);

		}

	TInt count = DatabaseReference().CountL();

	_LIT(KDatabaseCount, "Total number of contact entries is %d :");

	INFO_PRINTF2(KDatabaseCount, count);

	}

/* As mentioned earlier there will be some 1000 blank contacts in the database

 * Now any view will have it's own criteria like

 * -- view sort order i.e. the order in which the contact items in the view must be sorted

 * -- view preferences i.e. whether only contact cards or contact groups or both must be included in the view

 *    whether the unsorted contacts must be included in the view or not, if included, whether they must be included in the

 *    start of view or end  of view

 * It becomes necessary to supply the necessary envirnoment that meets the view criteia

 * Each view can supply its desired criteria. Based on this, the contacts in the database will be updated to meet the view specificattions

 */

void CPrepareDataTestStep::IterateThroAllSortOrderSectionsAndUpdateContactsInDatabaseL()

	{

	_LIT(KListOfSortOrderSections, "listofsortorder");

	TPtrC listOfSortOrderSectionsString;

	GetStringFromConfig(ConfigSection(), KListOfSortOrderSections, listOfSortOrderSectionsString);

	RArray<TPtrC>	listOfSortOrderSections;

	CleanupClosePushL(listOfSortOrderSections);

	ViewUtilityReference().TokenizeStringL(listOfSortOrderSectionsString, listOfSortOrderSections);

	for ( TInt i = 0; i < listOfSortOrderSections.Count(); ++i )

		{

		UpdateContactFieldsSpecificToSortOrderL(listOfSortOrderSections[i]);

		}

	CleanupStack::PopAndDestroy(&listOfSortOrderSections);

	}

/**

 * Here we are trying add contacts fields in the existing contacts such that they meet the contact views

 * Sort Order. Intentionally some of the contacts are updated with the contact fields of Null data to meet

 * the unsorted contacts criteria

 */

void CPrepareDataTestStep::UpdateContactFieldsSpecificToSortOrderL(const TPtrC& aSortOrderSection)

	{

	// Based on the sort order, the desired number of contacts will be updated i.e contact fields will be

	// added to the contacts in the database. The new fields added will be as per the sort order

	// at the end of this operation, if we constuct a contact view with this sort order

	// then the desired number of contacts will be included in the view

	_LIT(KViewSortOrder, "sortorder");

	TPtrC viewSortOrderString;

	GetStringFromConfig(aSortOrderSection, KViewSortOrder, viewSortOrderString);

	RContactViewSortOrder sortOrder = ViewUtilityReference().ConvertStringToSortOrderL(viewSortOrderString) ;

	CleanupClosePushL(sortOrder);

	_LIT(KNumOfSortableContacts, "numofsortablecontacts");

	TInt numOfSortableContacts;

	GetIntFromConfig(aSortOrderSection, KNumOfSortableContacts, numOfSortableContacts);

	// Here we are trying to update the desired number of contacts in the database

	// with Null contact fields in order to meet the unsortable contacts requirement

	_LIT(KNumUnSortableContacts, "numunsortedcontacts");

	TInt numUnSortableContacts;

	GetIntFromConfig(aSortOrderSection, KNumUnSortableContacts, numUnSortableContacts);

	const TInt KTotalNumOfContactsSpecificToThisSortOrder =  numOfSortableContacts + numUnSortableContacts;

	TInt numberOfReadySortableContacts = 0;

	TInt numberOfReadyUnSortableContacts = 0;

	// There may be contact items in the database that meet the sort order

	// We need be sure about the contact items that we should update

	RArray <TContactItemId> ListOfContactItemsThatCanUpdatedToMeetSortOrder;

	CleanupClosePushL(ListOfContactItemsThatCanUpdatedToMeetSortOrder);

	for(TInt i = 0; i < iListOfContactItemsInDatabase.Count(); ++i)

		{

		TContactItemId desiredContactItemId = iListOfContactItemsInDatabase[i];

		CContactItem* contact = DatabaseReference().OpenContactL(desiredContactItemId);

		CleanupStack::PushL(contact);

		CContactItemFieldSet& fieldSet = contact->CardFields();

		TInt firstContactFieldPosition = fieldSet.Find(sortOrder[0]);

		TInt secondContactFieldPosition = fieldSet.Find(sortOrder[1]);

		TInt thirdContactFieldPosition = fieldSet.Find(sortOrder[2]);

		if ((firstContactFieldPosition != KErrNotFound) &&  (secondContactFieldPosition != KErrNotFound) && (thirdContactFieldPosition!= KErrNotFound))

			{

			CContactItemField& firstContactItemField = fieldSet[firstContactFieldPosition];

			CContactItemField& secondContactItemField = fieldSet[secondContactFieldPosition];

			CContactItemField& thirdContactItemField  = fieldSet[thirdContactFieldPosition];

			if((firstContactItemField.Storage() == NULL) && (secondContactItemField.Storage() == NULL) && (thirdContactItemField.Storage() == NULL))

				{

		  		++numberOfReadyUnSortableContacts;

				}

			else

				{

				++numberOfReadySortableContacts;

				}

			}

		else

			{

			ListOfContactItemsThatCanUpdatedToMeetSortOrder.AppendL(desiredContactItemId);

			}

		CleanupStack::PopAndDestroy(contact);

		DatabaseReference().CloseContactL(desiredContactItemId);

		}

	if((numberOfReadyUnSortableContacts + numberOfReadySortableContacts) < KTotalNumOfContactsSpecificToThisSortOrder)

		{

		TInt j = 0;

		for(; j < (numOfSortableContacts-numberOfReadySortableContacts); ++j)

			{

			TContactItemId contactItemIdToBeUpdated = ListOfContactItemsThatCanUpdatedToMeetSortOrder[j];

			CContactItem* contact = DatabaseReference().OpenContactL(contactItemIdToBeUpdated);

			CleanupStack::PushL(contact);

			AddContactFieldL(*contact, sortOrder, ETrue);

			DatabaseReference().CommitContactL(*contact);

			DatabaseReference().CloseContactL(contactItemIdToBeUpdated);

			CleanupStack::PopAndDestroy(contact);

			}

		for(TInt k = j; k < (j + (numUnSortableContacts-numberOfReadyUnSortableContacts)); ++k)

			{

			TContactItemId contactItemIdToBeUpdated = ListOfContactItemsThatCanUpdatedToMeetSortOrder[k];

			CContactItem* contact = DatabaseReference().OpenContactL(contactItemIdToBeUpdated);

			CleanupStack::PushL(contact);

			AddContactFieldL(*contact, sortOrder);

			DatabaseReference().CommitContactL(*contact);

			DatabaseReference().CloseContactL(contactItemIdToBeUpdated);

			CleanupStack::PopAndDestroy(contact);

			}

		}

	CleanupStack::PopAndDestroy(2,&sortOrder);

	}

/** Adds contact fields specific to sort order,

 * Sort Order. Intentionally some of the contacts are updated with the contact fields of Null data to meet

 * the unsorted contacts criteria

 */

void CPrepareDataTestStep::AddContactFieldL(CContactItem& aContact, const RContactViewSortOrder& aSortOrder,

																								TBool aDataRequired)

	{

	const TInt KMaxSortOrderCount = 3;

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

		{

		TFieldType fieldType = aSortOrder[i];

		TStorageType storageType = GetStorageType(fieldType);

		CContentType* contentType = CContentType::NewL();

		CleanupStack::PushL(contentType);

		contentType->AddFieldTypeL(fieldType);

		CContactItemField* field = 	CContactItemField::NewL(storageType, *contentType);

		CleanupStack::PushL(field);

		if(aDataRequired)

			{

			SetDataL(fieldType, *field);

			}

		aContact.AddFieldL(*field);

		CleanupStack::Pop(field);

		CleanupStack::PopAndDestroy(contentType);

		}

	}

/**

 * Reads all the sections in the ini file relevant for updating the contacts database

 * in order to meet filter view requirements

 */

void CPrepareDataTestStep::IterateThroAllFilterViewsSectionsAndUpdateL()

	{

	_LIT(KListOfFilterViewSectionsString, "listoffilterviewsections");

	TPtrC listOfFilterViewSectionsString;

	GetStringFromConfig(ConfigSection(), KListOfFilterViewSectionsString, listOfFilterViewSectionsString);

	RArray<TPtrC>	listOfFilterViewSections;

	CleanupClosePushL(listOfFilterViewSections);

	ViewUtilityReference().TokenizeStringL(listOfFilterViewSectionsString, listOfFilterViewSections);

	for(TInt i = 0; i < listOfFilterViewSections.Count(); ++i)

		{

		UpdateContactsInDatabaseAsPerFilteredViewRequirementsL(listOfFilterViewSections[i]);

		}

	CleanupStack::PopAndDestroy(&listOfFilterViewSections);

	}

/**

 * Updates contacts in database as per filter view requirements specified in the ini section

 */

void CPrepareDataTestStep::UpdateContactsInDatabaseAsPerFilteredViewRequirementsL(const TPtrC& aFilteredViewSection)

	{

	_LIT(KViewSortOrder, "sortorder");

	TPtrC viewSortOrderString;

	GetStringFromConfig(aFilteredViewSection, KViewSortOrder, viewSortOrderString);

	RContactViewSortOrder sortOrder = 	ViewUtilityReference().ConvertStringToSortOrderL(viewSortOrderString);

	CleanupClosePushL(sortOrder);

	_LIT(KNumOfContactsWithFilter, "numofcontactswiththisfilter");

	TInt numOfContactsWithFilter;

	GetIntFromConfig(aFilteredViewSection, KNumOfContactsWithFilter, numOfContactsWithFilter);

	_LIT(KDesiredFilterString, "desiredFilter");

	TPtrC desiredFilterString;

	GetStringFromConfig(aFilteredViewSection, KDesiredFilterString, desiredFilterString);

	CContactDatabase::TContactViewFilter	viewFilter = ViewUtilityReference().GetContactViewFilterL(desiredFilterString);

	RArray<TContactItemId> contactSpecificToSortOrder;

	CleanupClosePushL(contactSpecificToSortOrder);

	RetrieveContactsSpecificToSortOrderL(sortOrder, contactSpecificToSortOrder);

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

		{

		TContactItemId id = contactSpecificToSortOrder[i];

		CContactItem* contactItem = DatabaseReference().OpenContactL(id);

		CleanupStack::PushL(contactItem);

		AddFilterBasedFieldsL(*contactItem, viewFilter);

		DatabaseReference().CommitContactL(*contactItem);

		DatabaseReference().CloseContactL(id);

		CleanupStack::PopAndDestroy(contactItem);

		}

	CleanupStack::PopAndDestroy(2, &sortOrder);

	}

/**

 * Retrieves contacts specific to desired sort order from the database

 */

void CPrepareDataTestStep::RetrieveContactsSpecificToSortOrderL(const RContactViewSortOrder& aSortOrder, RArray<TContactItemId>& aContactSpecificToSorder)

	{

	for(TInt i = 0; i < iListOfContactItemsInDatabase.Count(); ++i)

		{

		TContactItemId contactId = iListOfContactItemsInDatabase[i];

		CContactItem* contactItem = DatabaseReference().OpenContactL(contactId);

		CleanupStack::PushL(contactItem);

		TBool exists = CheckAllTheFieldsExists(*contactItem, aSortOrder);

		if(exists)

			{

			aContactSpecificToSorder.AppendL(contactId);

			}

		DatabaseReference().CloseContactL(contactId);

		CleanupStack::PopAndDestroy(contactItem);

		}

	}

/**

 * Checks whether all the three desired contact fields are present in the contact or not

 */

TBool CPrepareDataTestStep::CheckAllTheFieldsExists(const CContactItem& aContact, const RContactViewSortOrder& aSortOrder)

	{

	CContactItemFieldSet& fieldSet = aContact.CardFields();

	TInt firstContactFieldPosition = fieldSet.Find(aSortOrder[0]);

	TInt secondContactFieldPosition = fieldSet.Find(aSortOrder[1]);

	TInt thirdContactFieldPosition = fieldSet.Find(aSortOrder[2]);

	TInt error = KErrNotFound;

	if ((firstContactFieldPosition != error) &&  (secondContactFieldPosition != error) && (thirdContactFieldPosition!= error))

		{

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

/**

 * Data is read from the ini file about the matching strings expected to be present in some of the

 * contact fields and desired number of contacts in the database are updated with this matching string info

 */

void CPrepareDataTestStep::IterateThroAllMatchingStringSectionsAndUpdateL()

	{

	_LIT(KListOfMatchingStringSectionsString, "listofMatchingString");

	TPtrC listOfMatchingStringSectionsString;

	GetStringFromConfig(ConfigSection(), KListOfMatchingStringSectionsString, listOfMatchingStringSectionsString);

	RArray<TPtrC>	listOfMatchingStringSections;

	CleanupClosePushL(listOfMatchingStringSections);

	ViewUtilityReference().TokenizeStringL(listOfMatchingStringSectionsString, listOfMatchingStringSections);

	for(TInt i = 0; i < listOfMatchingStringSections.Count(); ++i)

		{

		UpdateContactsInDatabaseAsPerMatchingStringsL(listOfMatchingStringSections[i]);

		}

	CleanupStack::PopAndDestroy(&listOfMatchingStringSections);

	}

/**

 * Updates the contacts in the database based on the data available in the ini section

 * @param aMatchingStringSection - Relevant section in the ini file

 */

void CPrepareDataTestStep::UpdateContactsInDatabaseAsPerMatchingStringsL(const TPtrC& aMatchingStringSection)

	{

	_LIT(KViewSortOrder, "sortorder");

	TPtrC viewSortOrderString;

	GetStringFromConfig(aMatchingStringSection, KViewSortOrder, viewSortOrderString);

	RContactViewSortOrder sortOrder = ViewUtilityReference().ConvertStringToSortOrderL(viewSortOrderString);

	CleanupClosePushL(sortOrder);

	_LIT(KNumOfContactsWithFilter, "numofcontactswiththisstring");

	TInt numOfContactsWithThisString;

	GetIntFromConfig(aMatchingStringSection, KNumOfContactsWithFilter, numOfContactsWithThisString);

	_LIT(KDesiredMatchingString, "matchingstring");

	TPtrC desiredMatchingString;

	GetStringFromConfig(aMatchingStringSection, KDesiredMatchingString, desiredMatchingString);

	_LIT(KDesiredContactField, "contactfield");

	TPtrC desiredContactField;

	GetStringFromConfig(aMatchingStringSection, KDesiredContactField, desiredContactField);

	TUid uidInfo = GetContactFieldType(desiredContactField);

	RArray<TContactItemId> contactSpecificToSortOrder;

	CleanupClosePushL(contactSpecificToSortOrder);

	RetrieveContactsSpecificToSortOrderL(sortOrder, contactSpecificToSortOrder);

	for(TInt i = 0; (i < (contactSpecificToSortOrder.Count()) && (i < numOfContactsWithThisString)); ++i)

		{

		TContactItemId id = contactSpecificToSortOrder[i];

		CContactItem* contactItem = DatabaseReference().OpenContactL(id);

		CleanupStack::PushL(contactItem);	// contactItem

		AddMatchingStringToContactL(*contactItem, uidInfo, desiredMatchingString);

		DatabaseReference().CommitContactL(*contactItem);

		DatabaseReference().CloseContactL(id);

		CleanupStack::PopAndDestroy(contactItem);

		}

	CleanupStack::PopAndDestroy(2, &sortOrder);

	}

/**

 * Update contacts in database with desired string

 * This feature is useful while constructing Find Views, Sub Views etc..

 * @param aContact - Contact to be updated

 * @param aUid - uid of field in the contact item to be updated

 * @param aDesiredMatchingString - Matching string

 */

void CPrepareDataTestStep::AddMatchingStringToContactL(CContactItem& aContact, TUid aUid, const TPtrC& aDesiredMatchingString)

	{

	CContactItemFieldSet& fieldSet = aContact.CardFields();

	TInt pos = fieldSet.Find(aUid);

	if(pos == KErrNotFound)

		{

		TFieldType fieldType = aUid;

		TStorageType storageType = GetStorageType(fieldType);

		CContentType* contentType = CContentType::NewL();

		contentType->AddFieldTypeL(fieldType);

		CContactItemField* field = 	CContactItemField::NewL(storageType, *contentType);

		CleanupStack::PushL(field);

		field->TextStorage()->SetTextL(aDesiredMatchingString);

		aContact.AddFieldL(*field);

		CleanupStack::Pop();	// field

		}

	else

		{

		CContactItemField& field = fieldSet[pos];

		field.TextStorage()->SetTextL(aDesiredMatchingString);

		}

	}

void CPrepareDataTestStep::UpdateContactToSpecificStringL()

	{

		_LIT(KListOfSetDesiredStringSections, "listofcontacttoupdate");

		TPtrC listOfSections;

		GetStringFromConfig(ConfigSection(), KListOfSetDesiredStringSections, listOfSections);

		RArray<TPtrC>	listOfUpdateContact;

		CleanupClosePushL(listOfUpdateContact);

		ViewUtilityReference().TokenizeStringL(listOfSections, listOfUpdateContact);

		for ( TInt i = 0; i < listOfUpdateContact.Count(); ++i )

			{

			UpdateContactFieldsToDesireStingL(listOfUpdateContact[i]);

			}

		CleanupStack::PopAndDestroy(&listOfUpdateContact);

	}

void CPrepareDataTestStep::UpdateContactFieldsToDesireStingL(const TPtrC& aMatchingStringSection)

	{

	_LIT(KViewSortOrder, "sortorder");

	_LIT(KContactId, "contactid");

	_LIT(KDesiredString, "desiredstring");

	TPtrC viewSortOrderString;

	GetStringFromConfig(aMatchingStringSection, KViewSortOrder, viewSortOrderString);

	RContactViewSortOrder sortOrder = ViewUtilityReference().ConvertStringToSortOrderL(viewSortOrderString) ;

	CleanupClosePushL(sortOrder);

	TInt contactId;

	GetIntFromConfig(aMatchingStringSection, KContactId, contactId);

	TPtrC desiredSting;

	GetStringFromConfig(aMatchingStringSection, KDesiredString, desiredSting);

	RArray<TContactItemId> contactSpecificToSortOrder;

	CleanupClosePushL(contactSpecificToSortOrder);

	RetrieveContactsSpecificToSortOrderL(sortOrder, contactSpecificToSortOrder);

	CContactItem* contactItem = DatabaseReference().OpenContactL(contactId);

	CleanupStack::PushL(contactItem);