/*

* Copyright (c) 2007 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:  Active object to read all the contacts from a 

*                particular data store. Handles add/ modify/ delete of contacts.

*

*/

// SYSTEM INCLUDES

#include <barsread.h>

#include <coemain.h>

#include <utf.h>

#include <e32std.h>

#include <badesca.h>

#include <CVPbkContactManager.h>

#include <CVPbkContactStoreUriArray.h>

#include <CVPbkContactFieldIterator.h>

#include <CVPbkFieldTypeRefsList.h>

#include <CVPbkContactLinkArray.h>

#include <TVPbkContactStoreUriPtr.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkContactStoreList.h>

#include <MVPbkContactStore.h>

#include <MVPbkStoreContact.h>

#include <MVPbkContactFieldData.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkContactLink.h>

#include <VPbkEng.rsg>

#include <VPbkContactStoreUris.h>

#include <CVPbkContactViewDefinition.h>

#include <MVPbkContactViewBase.h>

#include <VPbkContactView.hrh>

#include <CVPbkContactIdConverter.h>

#include <centralrepository.h>

#include <MVPbkContactGroup.h>

#include <CVPbkFieldTypeSelector.h>

#include <CVPbkContactLinkArray.h>

#include <CVPbkSortOrder.h>

#include <data_caging_path_literals.hrh>

#include <bautils.h>

// USER INCLUDES

#include "cpcscontactstore.h"

#include "CPsData.h"

#include "CPcsDebug.h" 

#include "CPcsDefs.h"

#include <contactsort.rsg>

// CONSTANTS

const TInt KSimStoreOffset            = -5000;

_LIT(KResourceFileName, "contactsort.rsc");

_LIT(KPcsViewPrefix,"PCSView_");

// FORWARD DECLARATION

// ============================== MEMBER FUNCTIONS ================================

// ---------------------------------------------------------------------------------

// 2 phase construction

// ---------------------------------------------------------------------------------

CPcsContactStore* CPcsContactStore::NewL(CVPbkContactManager&  aContactManager,

                                         MDataStoreObserver& aObserver,

                                         const TDesC& aUri)

{

	PRINT ( _L("Enter CPcsContactStore::NewL") );

	CPcsContactStore* self = new ( ELeave ) CPcsContactStore( );

	CleanupStack::PushL( self );

	self->ConstructL(aContactManager,aObserver,aUri);

	CleanupStack::Pop( self );

	PRINT ( _L("End CPcsContactStore::NewL") );

	return self;

}

// ---------------------------------------------------------------------------------

// Constructor

// ---------------------------------------------------------------------------------

CPcsContactStore::CPcsContactStore():

	CActive( CActive::EPriorityLow),

    iAllContactLinksCount(0),

    iFetchedContactCount(0),

    iContactViewReady(EFalse)

{

    PRINT ( _L("Enter CPcsContactStore::CPcsContactStore") );

    CActiveScheduler::Add( this );

	PRINT ( _L("End CPcsContactStore::CPcsContactStore") );

}

// ---------------------------------------------------------------------------------

// CPcsContactStore::ConstructL() 

// 2nd phase constructor

// ---------------------------------------------------------------------------------

void CPcsContactStore::ConstructL(CVPbkContactManager&  aContactManager,

                                  MDataStoreObserver& aObserver,

                                  const TDesC& aUri)

{

    PRINT ( _L("Enter CPcsContactStore::ConstructL") );

	iContactManager  = &aContactManager;

	iObserver = &aObserver;

	iUri = HBufC::NewL(aUri.Length());

	iUri->Des().Copy(aUri);

	// create containers for holding the sim data      

    iSimContactItems = CVPbkContactLinkArray::NewL();

	// for creating sort order

	iSortOrder = CVPbkFieldTypeRefsList::NewL();

	// Read the fields to cache from the central repository

	ReadFieldsToCacheFromCenrepL();

    // Local timer for block fetch delay

    iTimer.CreateLocal();

    // Initial state

	iNextState = ECreateView;

	IssueRequest();

	PRINT ( _L("End CPcsContactStore::ConstructL") );

}

// ---------------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------------

CPcsContactStore::~CPcsContactStore() 

{

	PRINT ( _L("Enter CPcsContactStore::~CPcsContactStore") );

	delete iContactViewBase;

	iContactViewBase = NULL;

	delete iSortOrder;

	iSortOrder = NULL;

    delete iSimContactItems;

    iSimContactItems = NULL ;

	delete iWait;

	iWait = NULL;

	delete iUri;

	iUri = NULL;

	iTimer.Cancel();

    iTimer.Close();

	iFieldsToCache.Close();	

	iFs.Close();

	if(IsActive())

	{

		Deque();

	}

	PRINT ( _L("End CPcsContactStore::~CPcsContactStore") );

}

// ---------------------------------------------------------------------------------

// Handles addition/deletion/modification of contacts

// ---------------------------------------------------------------------------------

void CPcsContactStore::HandleStoreEventL(MVPbkContactStore& aContactStore, 

                TVPbkContactStoreEvent aStoreEvent)

{

   	PRINT ( _L("Enter CPcsContactStore::HandleStoreEventL") );

	switch (aStoreEvent.iEventType) 

	{

		case TVPbkContactStoreEvent::EContactAdded:

		{

		    PRINT ( _L("Add contact/group event received") );

		    iContactManager->RetrieveContactL( *(aStoreEvent.iContactLink),

	                                           *this);

			break;

		}

        case TVPbkContactStoreEvent::EUnknownChanges:

            {

            iObserver->RemoveAll( *iUri );

            iContactViewReady = EFalse;

            iContactViewBase->AddObserverL(*this);

            }

            break;

		case TVPbkContactStoreEvent::EContactDeleted:

		case TVPbkContactStoreEvent::EContactChanged:

		case TVPbkContactStoreEvent::EGroupDeleted:

		case TVPbkContactStoreEvent::EGroupChanged:

		{

		    if ( aStoreEvent.iEventType == TVPbkContactStoreEvent::EContactChanged ) 

		    {

		    	PRINT ( _L("Change contact/group event received") );

		    }

		    else 

		    {

		    	PRINT ( _L("Delete contact/group event received") );

		    }

			CVPbkContactIdConverter* converter = NULL;

		    TRAPD ( err, converter = CVPbkContactIdConverter::NewL( aContactStore ) );

	        TInt32 contactId(-1);

	        if ( err == KErrNotSupported )

	        {

	            // sim domain  

	            // Pass the sim observer string in the next line

	            TInt contactLocation =  iSimContactItems->Find(*aStoreEvent.iContactLink);	

				if( KErrNotFound != contactLocation)

				{

				    // We are not removing from the array cache. If you try to fetch, 

				    // then it will give an error			       

				    TInt index = CreateCacheIDfromSimArrayIndex (contactLocation);

	                iObserver->RemoveData(*iUri,index );

		       	} 	               	           

	        }

	        else

	        {

	           // cntdb domain

	           // Get contact id by mapping the link

	           contactId = converter->LinkToIdentifier(*(aStoreEvent.iContactLink));

	           // Remove the contact

		       iObserver->RemoveData(*iUri, contactId);

		    }

		    delete converter;

		    converter = NULL;

	        if (( aStoreEvent.iEventType == TVPbkContactStoreEvent::EContactChanged ) ||

	            ( aStoreEvent.iEventType == TVPbkContactStoreEvent::EGroupChanged ) )

	        {

	  		    // Add the contact

	  		   iContactManager->RetrieveContactL( *(aStoreEvent.iContactLink),

	  		                                                           *this );

	        }

			break;

		}

	}

	PRINT ( _L("End CPcsContactStore::HandleStoreEventL") );

}

// ---------------------------------------------------------------------------

//  Returns ths database URI

// ---------------------------------------------------------------------------

TDesC& CPcsContactStore::GetStoreUri()

{

  return *iUri;

}

// ---------------------------------------------------------------------------

//  Callback Method. Called when one Retrieve operation is complete

// --------------------------------------------------------------------------- 

void CPcsContactStore::VPbkSingleContactOperationComplete(

        MVPbkContactOperationBase& aOperation, MVPbkStoreContact* aContact)

{    

    iFetchedContactCount++;

	// Handle the fetched contact....

	TRAPD(err, HandleRetrievedContactL(aContact) );

	if( err != KErrNone)

	{

		iObserver->UpdateCachingStatus(*iUri, err);

	}

	MVPbkContactOperationBase* Opr = &aOperation;

	if ( Opr )

	{

		delete Opr;

		Opr = NULL;

	}

	// Update the iNextState variable to proper state

	if( iFetchedContactCount == iAllContactLinksCount )

	{

	    // Fetch complete

	    // Update the caching status

		iObserver->UpdateCachingStatus(*iUri, ECachingComplete);

		iNextState = EComplete;

		IssueRequest();

	}

	else if ( (iFetchedContactCount % KLinksToFetchInOneGo) == 0 )

	{

	    // Fetch next block

		iNextState = EFetchContactBlock;

		IssueRequest();

	}

}

// ---------------------------------------------------------------------------

//  Callback Method.Called when one Retrieve operation fails.

// ---------------------------------------------------------------------------

void CPcsContactStore::VPbkSingleContactOperationFailed(

        MVPbkContactOperationBase& /*aOperation*/, TInt /*aError*/ )

{

  	PRINT ( _L("Enter CPcsContactStore::VPbkSingleContactOperationFailed") );

	iFetchedContactCount++;

	// Update the iNextState variable to proper state

	if( iFetchedContactCount == iAllContactLinksCount )

	{

		// Fetch complete

		iObserver->UpdateCachingStatus(*iUri, ECachingComplete);

		iNextState = EComplete;

		IssueRequest();

	}

	else if ( (iFetchedContactCount % KLinksToFetchInOneGo) == 0 ) 

	{

		// Fetch next block

		iNextState = EFetchContactBlock;

		IssueRequest();

	}

	PRINT ( _L("End CPcsContactStore::VPbkSingleContactOperationFailed") );

}

// ---------------------------------------------------------------------------

// Handles the operations for a single contact after it is fetched

// ---------------------------------------------------------------------------

void CPcsContactStore::HandleRetrievedContactL(MVPbkStoreContact* aContact)

{    

    // Fill the contact link

	MVPbkContactLink* tmpLink = aContact->CreateLinkLC();

    // If the link is null, then it is not put on the cleanup stack,

    // so we need not pop in such a case

    if( NULL == tmpLink )

    {

        delete aContact;

        aContact = NULL;

    	return;

    }

    // Recover the URI

    HBufC* storeUri = HBufC::NewL(aContact->ParentStore().StoreProperties().Uri().UriDes().Length());

    storeUri->Des().Copy(aContact->ParentStore().StoreProperties().Uri().UriDes());

	CPsData *phoneContact = CPsData::NewL();

	// Fill the contact id

	CVPbkContactIdConverter* converter = NULL;

	TRAPD ( err, converter = CVPbkContactIdConverter::NewL( aContact->ParentStore() ) );

	if ( err == KErrNotSupported )

	{

		// simdb domain	

		PRINT ( _L("SIM domain data received") );

		TInt tempIndex =  iSimContactItems->Find(*tmpLink);	

		if( KErrNotFound == tempIndex)

		    {

		    	tempIndex = iSimContactItems->Count();

	        iSimContactItems->AppendL(tmpLink);

	      }

	    //Create a dummy sim index and set it

	    TInt simIndex = CreateCacheIDfromSimArrayIndex(tempIndex);

	    phoneContact->SetId(simIndex);

	    // Set the contact link 

	    HBufC8* extnInfo = tmpLink->PackLC();

	    phoneContact->SetDataExtension(extnInfo);

	    CleanupStack::Pop();//extnInfo		      

	    CleanupStack::Pop(); // tmpLink

	}

	else 

	{

	    // cntdb domain

		TInt32 contactId = converter->LinkToIdentifier(*tmpLink);

		phoneContact->SetId(contactId);		

		CleanupStack::PopAndDestroy(); // tmpLink

	}

	// Take the ownership

	aContact->PushL();

	MVPbkContactGroup* myContactGroup= aContact->Group();

	// The retrieved contact can be a contact item or a contact group, Handle accordingly

	if ( NULL == myContactGroup )

	{

		// The fetched contact item (and not a contact group.)

		GetDataForSingleContactL( *aContact, phoneContact );

		//Add the data to the relevent cache through the observer

		iObserver->AddData(*storeUri, phoneContact);

	}

	else

	{  

	    // Fetch the group name 

	    HBufC* groupName = HBufC::NewL(myContactGroup->GroupLabel().Length());

	    groupName->Des().Copy(myContactGroup->GroupLabel());

	    TInt grpArrayIndex = -1; 

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

	    {

	    	if(iFieldsToCache[i] == R_VPBK_FIELD_TYPE_LASTNAME)

			 {

			 grpArrayIndex = i;

			 }

			 phoneContact->SetDataL(i,KNullDesC);

	    }

	    if(grpArrayIndex != -1)

	    {

	    	phoneContact->SetDataL(grpArrayIndex,groupName->Des());

	    	storeUri->Des().Copy(KVPbkDefaultGrpDbURI);	    

        // Check for the contact in the group.

	    MVPbkContactLinkArray* contactsContainedInGroup = myContactGroup->ItemsContainedLC();

        for(TInt i = 0; i < contactsContainedInGroup->Count(); i++)

		{

			TInt grpContactId = converter->LinkToIdentifier(contactsContainedInGroup->At(i));

			phoneContact->AddIntDataExtL(grpContactId);

		}

		CleanupStack::PopAndDestroy(); // contactsContainedInGroup

 		//Add the data to the relevent cache through the observer

	    iObserver->AddData(*storeUri, phoneContact);

	 	}

	    else

	    {

	    	//We do not add anything here since Lastname does not exists in cenrep

	    	delete 	phoneContact;

	    	phoneContact = NULL;

	    }

	    delete groupName;

	    groupName = NULL;

	}

	delete converter;

	converter = NULL;

	delete storeUri;

    storeUri = NULL;

	CleanupStack::PopAndDestroy(aContact); // aContact

}

// ---------------------------------------------------------------------------

// Fetches the data from a particular contact 

// --------------------------------------------------------------------------- 

void CPcsContactStore::GetDataForSingleContactL( MVPbkBaseContact& aContact,

                                                 CPsData* aPhoneData )

{      

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

    {

	    aPhoneData->SetDataL(i, KNullDesC);

		AddContactFieldsL( aContact, iFieldsToCache[i], aPhoneData);			

    }

}

// ---------------------------------------------------------------------------

// Add the data from contact fields

// --------------------------------------------------------------------------- 

void CPcsContactStore::AddContactFieldsL( MVPbkBaseContact& aContact,

                                          TInt afieldtype,

                                          CPsData *aPhoneData)

{

	const MVPbkFieldType*  myContactDataField = 

		iContactManager->FieldTypes().Find( afieldtype );

	CVPbkBaseContactFieldTypeIterator* itr = 

		CVPbkBaseContactFieldTypeIterator::NewLC( *myContactDataField, 

		aContact.Fields() );	

	// Iterate through each of the data fields

	while ( itr->HasNext() )

	{

		const MVPbkBaseContactField* field = itr->Next();

	    if ( ( field->FieldData()).DataType() == EVPbkFieldStorageTypeText )

		{

			const MVPbkContactFieldTextData& data = 

				MVPbkContactFieldTextData::Cast( field->FieldData() );

			//If the field exist in iFieldsToCache, then set it

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

			{

				if(afieldtype == iFieldsToCache[i])

				{	

                    // Check if the field has any data entry. If so

                    // concatenate the next data to the existing one.

                    // A unit seperator is used to show that these are

                    // two entries.

                    HBufC* previousData = aPhoneData->Data(i);

                    if( (previousData != NULL) && (previousData->Des().Length()> 1) )

                    {

                        HBufC* newData = HBufC::NewLC(data.Text().Length() + previousData->Des().Length() + 5);

                        TPtr newDataPtr(newData->Des());

                        newDataPtr.Append(previousData->Des());

                        newDataPtr.Append(KSpaceCharacter);

                        newDataPtr.Append(KUnitSeparator);

                        newDataPtr.Append(KSpaceCharacter);

                        newDataPtr.Append(data.Text());