// 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 <s32std.h>

#include <f32file.h>

#include <cntdef.h>

#include <cntitem.h>

#include <cntfield.h>

#include <cntfldst.h>

#include <cntdb.h>

#include "CNTSTD.H"

#include "CNTPROF.H"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "cntfieldheader.h"

#endif

EXPORT_C CContactItemFieldSet* CContactItemFieldSet::NewL()

/** Allocates and constructs a new field set.

@return Pointer to the newly created field set. */

	{ // static 

	CContactItemFieldSet* self=CContactItemFieldSet::NewLC();

	CleanupStack::Pop(); // self

	return self;

	}

EXPORT_C CContactItemFieldSet* CContactItemFieldSet::NewLC()

/** Allocates and constructs a new field set.

@return Pointer to the newly created field set. This is left on the cleanup 

stack. */

	{ // static

	CContactItemFieldSet* self=new(ELeave) CContactItemFieldSet;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C CContactItemFieldSet::~CContactItemFieldSet()

/** The destructor frees all resources owned by the field set, prior to its destruction. */

	{

	if (iFields)

		{

		iFields->ResetAndDestroy();

		delete iFields;

		}

	}

CContactItemFieldSet::CContactItemFieldSet()

	{}

void CContactItemFieldSet::ConstructL()

	{

	iFields=new(ELeave) CArrayPtrFlat<CContactItemField>(4);

	}

const CContactItemField* CContactItemFieldSet::FindById(TInt aId) const

	{

	const CContactItemField* field=NULL;

	for (TInt ii=0;ii<iFields->Count();ii++)

		{

		field=iFields->At(ii);

		if (field->Id()==aId)

			return(field);

		}

	return(NULL);

	}

EXPORT_C TInt CContactItemFieldSet::FindNext(TFieldType aFieldType,TInt aStartPos) const

/** Finds the next field in the field set with the specified field type.

@param aFieldType The field type of interest.

@param aStartPos The index within the field set array at which to start the 

search. By default set to KContactFieldSetSearchAll, to find the first field. 

Must be a valid array index, or the function raises a panic.

@return If found, the index of the field within the field set, or KErrNotFound 

if not found. */

	{

	return(FindNext(aFieldType,KUidContactFieldMatchAll,aStartPos));

	}

EXPORT_C TInt CContactItemFieldSet::FindNext(TFieldType aFieldType,TUid aMapping,TInt aStartPos) const

/** Finds the next field in the field set containing both the content type mapping 

and the field type specified.

@param aFieldType The field type of interest.

@param aMapping The content type mapping of interest.

@param aStartPos The index within the array at which to start the search. By 

default set to KContactFieldSetSearchAll, to find the first field. Must be 

a valid array index, or the function raises a panic.

@return If found, the index of the field within the field set, or KErrNotFound 

if not found. */

	{

	const TInt count=iFields->Count();

	TInt pos=(aStartPos==KContactFieldSetSearchAll? 0 : aStartPos);

	TInt ii=KErrNotFound;

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

		{

		const CContentType& contentType=(*iFields)[ii]->ContentType();

		if (contentType.Mapping()==KUidContactFieldMatchAll || aMapping==KUidContactFieldMatchAll || contentType.Mapping()==aMapping)

			if (aFieldType==KUidContactFieldMatchAll || contentType.ContainsFieldType(aFieldType))

				return ii;

		}

	return KErrNotFound;

	}

void CContactItemFieldSet::SetFieldId(CContactItemField& aField)

	{

	TInt id=iFields->Count();

	TInt count=iFields->Count();

	FOREVER

		{

		TInt loop=0;

		for(;loop<count;loop++)

			if ((*iFields)[loop]->Id()==id)

				break;

		if (loop==count)

			{

			aField.SetId(id);

			break;

			}

		id++;

		}

	}

EXPORT_C CContactItemFieldSet& CContactItemFieldSet::AddL(CContactItemField& aField)

/** Appends a field to the field set. The field set takes ownership of the field.

@param aField Reference to the field to add to the field set. The field's 

ID is updated.

@return Reference to the current field set. */

	{

	__ASSERT_DEBUG(&aField!=NULL,Panic(ECntPanicNullPointer));

	SetFieldId(aField);

	iFields->AppendL(&aField);

	return (*this);

	}

EXPORT_C void CContactItemFieldSet::Remove(TInt aIndex)

/** Removes a field from the field set.

@param aIndex The index of the field to delete. Must be a valid index within 

the field set or the function raises a panic. */

	{

	delete (*iFields)[aIndex];

	iFields->Delete(aIndex);

	}

EXPORT_C void CContactItemFieldSet::Move(TInt aFrom, TInt aTo)

/** Changes a field's position within the field set.

Both indexes specified must be valid (i.e. between zero and Count()-1 inclusive), 

or the function raises a panic.

@param aFrom The index of the field to move.

@param aTo The index of the new position within the field set. */

	{

	CContactItemField *moveField=(*iFields)[aFrom];

	if (aFrom<aTo)

		{

		for(TInt loop=aFrom;loop<aTo;loop++)

			(*iFields)[loop]=(*iFields)[loop+1];

		}

	else

		{

		for(TInt loop=aFrom;loop>aTo;loop--)

			(*iFields)[loop]=(*iFields)[loop-1];

		}

	(*iFields)[aTo]=moveField;

	}

EXPORT_C void CContactItemFieldSet::InsertL(TInt aIndex,CContactItemField& aField)

/** Inserts a field into the field set.

@param aIndex The position in the field set at which to insert the field. 

If equal to or greater than the number of elements in the field set, the field 

is appended to the field set.

@param aField Reference to the field to add to the field set. The field's ID 

is updated. */

	{

	__ASSERT_DEBUG(&aField!=NULL,Panic(ECntPanicNullPointer));

	SetFieldId(aField);

	TInt count=iFields->Count();

	if (count>aIndex)

		iFields->InsertL(aIndex,&aField);

	else

		iFields->AppendL(&aField);

	}

/**

Find and return the index of the best matched template field. The method uses a matching algorithm which compares the content type of the template fields with that of the incoming contact item.

Matching Algorithm Steps:

========================

The algorithm is based on a scoring mechanism counting 'hits' and 'misses' in order to find the best possible field match within the fieldset of the template.

1. Loop through all the contact item fields of the template.

For each template field:

2. Perform a strict, or exact, match between the vCard mappings of the template field and the field to be matched.

3. If the vCard mappings match exactly, compare User Flags values and amend the overall score accordingly.

4. Loop through all the field types (TFieldType array) stored as part of the content type of the field to be matched.

For each field type of the field to be matched:

5. Loop through the field types of the iterated template field to find a field type match. Amend the 'hits' and 'misses' count accordingly.

6. Calculate the overall score weighing the 'hits' and 'misses' count.

7. Amend the overall score count in order to account for special cases (e.g. user defined fields)

8. Compare the overall score with the best score. If score > current best score, replace the 'bestScore' count and 'bestMatch' index.

9. Return the 'bestMatch' field index of the template field.

@param aContentType		The content type of the field to find a match for.

@param aUserFlags		The user flags of the field to find a match for.

@param aExactMatch		Boolean to indicate an exact field match within the template.

@return The index of the best matched template field, if found, else KErrNotFound.

*/

TInt CContactItemFieldSet::MatchTemplateField(const CContentType& aContentType,TUint aUserFlags,TBool &aExactMatch) const

	{

	const TInt count=Count();

	TInt bestScore=5;	// Has to be better than one or fail the match

	TInt bestMatch=KErrNotFound;

	TInt contentTypeCount=aContentType.FieldTypeCount();

	// Loop through all the template fields to find the best field match

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

		{

		const CContactItemField& field=*(*iFields)[ii];

		const CContentType &fieldContentType=field.ContentType();

		// Strict matching executed on the vCard mappings in order to avoid matching non-related fields e.g. Fax and Address fields.

		// NOTE: The vCard mappings are intended to match the vCard PROPERTY (e.g. TEL in TEL;HOME;FAX:01234), wherein the field is to be exported into a vCard.

		if (fieldContentType.Mapping()==aContentType.Mapping())

			{

			TInt score=fieldContentType.Mapping()==KUidContactFieldVCardMapUnusedN?0:100;

			TInt hits=0;

			TInt misses=0;

			// The criteria for an exact match of the User Flags has been changed

			// from a mandatory requirement to a preference within the scoring system

			if (aUserFlags==0 || field.UserFlags()==aUserFlags)

				{

				++score;

				}

			// NOTE: A common Field Types array stores BOTH the Field Type in addition to the Extra Mappings

			//

			// A. Field Type     = Contact item field's type defined internally

			// B. Extra Mappings = Refer to the vCard PARAMETERS (e.g. FAX and HOME in TEL;HOME;FAX:01234)

			//

			// The Field Type and Extra Mappings are defined as part of the FIELD structure within the template (cntmodel.rss)

			//

			// C. Field Types array = A (Field Type, first element) + B (Extra Mappings, all elements after the first element)

			// Loop through the incoming contact item field's Field Types (C)

			for(TInt contactFieldTypeLoop=0; contactFieldTypeLoop < contentTypeCount; ++contactFieldTypeLoop)

				{

				// Match EACH of the incoming contact item field's Field Types (C) within the template field's Field Types (C)

				if(ContainsFieldTypeMapping(fieldContentType,aContentType.FieldType(contactFieldTypeLoop)))

					{

					++hits;

					}

				else

					{

					++misses;

					}				

				}

			// Check if the incoming contact item has a vCard property mapping

			// that is also present in the current template field's Field Types.

			// This covers the (unusual) case where a template field is defined

			// to have a vCard property mapping which is also the same as one of

			// field types (which contains property parameter mappings).

			for(TInt fieldTypeIdx=0; fieldTypeIdx < fieldContentType.FieldTypeCount(); ++fieldTypeIdx)

				{

				if(fieldContentType.FieldType(fieldTypeIdx) == aContentType.Mapping())

					{

					++hits;

					}

				}

			misses+=fieldContentType.FieldTypeCount()-hits;

			score+=10*hits-5*misses;

			if (!field.UserAddedField())

				{

				score+=3;	// Non-user added field takes priority over user added fields

				}

			if (fieldContentType.ContainsFieldType(KUidContactFieldVCardMapWORK))

				{

				score+=1;	// Work fields take priority over home fields

				}

			if (score>bestScore)

				{

				aExactMatch=(misses==0);

				bestScore=score;

				bestMatch=ii;

				}

			}

		}

	return bestMatch;

	}

// Attempt to find a contact item field type within the Field Types array (Field Types array = Field Type (internal) + Extra Mappings) of the base contact item.

// NOTE: This function does not include the base contact item field's vCard mapping whilst looking for the Field Type

TBool CContactItemFieldSet::ContainsFieldTypeMapping(const CContentType& aBaseFieldContentType, const TFieldType& aContactFieldType) const

	{

	// Loop through all the template Field Types to attempt to match the individual Field Type of the incoming contact item's field

	for(TInt templateFieldTypeLoop=0; templateFieldTypeLoop < aBaseFieldContentType.FieldTypeCount(); ++templateFieldTypeLoop)

		{

		if(aBaseFieldContentType.FieldType(templateFieldTypeLoop) == aContactFieldType)

			{

			return ETrue;

			}

		}

	return EFalse;

	}

/**

@internalTechnology 

*/

EXPORT_C TStreamId CContactItemFieldSet::StoreL(CStreamStore& aStore,const CContactItem* aTemplate,RWriteStream& aTextStream,CStreamStore& aBlobStore,CContactTables* aTables)

	{

	const TInt count=Count();

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

		{

		CContactItemField* field=(*iFields)[ii];

		if (aTemplate)

			{

			const CContactItemFieldSet& templateFields = aTemplate->CardFields();

			field->UpdateFieldFlags(templateFields);

			}

		else

			{

			field->SetLabelUnspecified(EFalse);

			}

		}

	return StoreL(aStore,aTextStream,aBlobStore,aTables);

	}

EXPORT_C TStreamId CContactItemFieldSet::StoreL(CStreamStore& aStore,RWriteStream& aTextStream,CStreamStore& aBlobStore)

/** Stores the field set to a stream store.

@internalTechnology

@param aStore Stream store to which the field set is written.

@param aTextStream Stream to which data stored in text fields (with a storage 

type of KStorageTypeText) is written.

@param aBlobStore Stream store to which data stored in non-text fields is written.

@return The ID of the stream store. */

	{

	//Overloaded to maintain SC.

	return (StoreL(aStore,aTextStream,aBlobStore,NULL));

	}

/* 

Store all contact fields in this field set into given header and data stores.

In SQLite data schema, contact field data is saved in the stream store (aStore) as:

contact-item-field-set = number-of-fields *field		

    ; <field> repeated <number-of-fields> times

field = contact-field-atts [ stream-id ] field-id template-id [ hint-value *mapping *additional-field ] [ label-length [ label ] ]

	; 1st optional part is there if the contact field is NOT stored as text.

	; if the field uses the template's content type, the 2nd optional part is left out

	; <additional-field> is repeated a number of times as specified by <number-of-additional-fields> inside hint-value

	; mapping is there if vcard-mapping-id-mask in hint-valute is set

	; 3rd optional part is there if there is a label which overrides the template label. <label> is left out if <label-length> is zero

contact-field-atts = attrib-store

attrib-store =	attribs field-type extended-attribs				

	; 32 bits -- order is endian-dependent

attribs	= 14BIT						

	; 14 bitfields: Hidden, ReadOnly, Synchronize, Disabled, 

	;	4 user-defined fields, OverRidesLabel, UsesTemplateData, 

	;	UserAddedField, Template, LabelUnspecified and Deleted (in that order), 

field-type = 4BIT						; 0..16

extended-attribs = 8BIT

    ; 8 bitfields: Private, SpeedDial, EUserDefinedFilter and 

    ; EUserDefinedFilter1-4(in that order)		

hint-value = vcard-mapping-id-mask *number-of-additional-fields *hint-value

    ; 32 bits -- order is endian-dependent

    ; hint-value and number-of-additional-fields is there if UsesTemplateData is NOT set in attribs

vcard-mapping-id-mask= 1BIT   

number-of-additional-fields = 7BIT

hint-value = 24BIT

mapping = Int32

field-id =UInt32

template-id =UInt32

stream-id =UInt32

label-length = Int32

label = Descriptor

@param aStore the stream store for data header

@param aTextStream the stream to store text data

@param aBlobStore  the stream store for blob data

@return stream id the data header stored in aStore.

*/

TStreamId CContactItemFieldSet::StoreL(CStreamStore& aStore, RWriteStream& aTextStream, CStreamStore& aBlobStore, CContactTables* /*aTables*/)

	{

	CArrayFix<TInt>* fullFields = new(ELeave) CArrayFixFlat<TInt>(4);

	CleanupStack::PushL(fullFields);  // push here to make cleanup easier

	CArrayFix<TFieldHeader>* fieldHeader = new(ELeave) CArrayFixFlat<TFieldHeader>(5);

	CleanupStack::PushL(fieldHeader);

	TInt textFieldIndex = 0;

	const TInt KCount = Count();

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

	    {  

	    // find all non-empty fields

		CContactItemField* field = (*iFields)[ii];

		if (!field->IsDeleted()) 

			{

			// only save non-empty content in the blob

			fullFields->AppendL(ii); // save for later

			//Add the text storage field data from the field to the blob

			fieldHeader->AppendL(field->StoreL(aTextStream, aBlobStore, textFieldIndex));

			if (field->StorageType() == KStorageTypeText)

			    {

				++textFieldIndex;

			    }

			}

		}

	// adjust the hint values for non-empty fields only

	RStoreWriteStream rootStream;

	TStreamId streamId = rootStream.CreateLC(aStore);

	const TInt KHintCount = fieldHeader->Count();

	rootStream << TCardinality(KHintCount);

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

		{

		CContactItemField* field=(*iFields)[(*fullFields)[ii]];

		field->PopulateStoreL(rootStream, ii, *fieldHeader);

		}	

	rootStream.CommitL();

	aStore.CommitL();

	CleanupStack::PopAndDestroy(3, fullFields); // rootStream, fieldHeader, fullFields

	return streamId;

	}

HBufC* CContactItemFieldSet::LoadTextStreamLC(RReadStream& aStream)

	{

	TInt maxlen=0;

	if (aStream.Source())

		maxlen=aStream.Source()->SizeL(); 

	maxlen=maxlen/2;

	HBufC* textStream=HBufC::NewLC(maxlen);

	if (maxlen)

		{

		TPtr des=textStream->Des();

		aStream.ReadL(des,maxlen);

		}

	return(textStream);

	}

void CContactItemFieldSet::RestoreAndAddTemplateL(CStreamStore& aStore, TStreamId aId,CStreamStore* aBlobStore,const CContactItemViewDef& aViewDef,

									const CContactItem* aTemplate,RReadStream& aReadStream,CContactTables* aContactsTable,RArray<TInt>* aEmailIdArray)

	{

	if (aViewDef.Use()==CContactItemViewDef::EIncludeFields && aViewDef.Count()==0)

		return; // zzz temp kludge, fix this properly

	if (aTemplate)

		{

		CContactItemFieldSet *original=CContactItemFieldSet::NewLC();

		original->RestoreL(aStore,aId,aBlobStore,aViewDef,aTemplate,aReadStream,aContactsTable,aEmailIdArray);

		TInt count=original->Count();

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

			{

			CContactItemField* additionalField=CContactItemField::NewLC((*original)[loop]);

			AddL(*additionalField);

			CleanupStack::Pop(); // additionalField

			}

		CleanupStack::PopAndDestroy(); // original

		}

	else

		RestoreL(aStore,aId,aBlobStore,aViewDef,NULL,aReadStream,aContactsTable,aEmailIdArray);

	}

/** 

Restores the field set using a view definition.

@internalTechnology

@param aStore Store from which to restore the field set.

@param anId The root stream ID of aStore.

@param aBlobStore If specified, the stream store from which data stored in 

non-text fields is read.

@param aViewDef The view definition to use.

@param aReadStream Read stream from which data stored in text fields (with 

a storage type of KStorageTypeText) is read. 

*/

EXPORT_C void CContactItemFieldSet::RestoreL(CStreamStore& aStore, TStreamId anId,CStreamStore* aBlobStore,const CContactItemViewDef& aViewDef,RReadStream& aReadStream)

    {

	//THIS FUNCTION IS TO BE REMOVED....