/*

* 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 <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>

#include <featmgr.h>

#include <CPbk2SortOrderManager.h>

// USER INCLUDES

#include "cpcscontactstore.h"

#include "CPsData.h"

#include "CPcsDebug.h" 

#include "CPcsDefs.h"

#include <contactsort.rsg>

// CONSTANTS

namespace {

const TInt KSimStoreOffset            = -5000;

const TInt KTimerInterval             = 100000;   // 100 milliseconds

_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 ),

    iInitialContactCount( 0 ),

    iFetchBlockLowerNumber( 0 ),

    iFetchBlockUpperNumber( 0 ),

    iVPbkCallbackCount( 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 = aUri.AllocL();

	// 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( 0 );

    FeatureManager::InitializeLibL();

    if( FeatureManager::FeatureSupported( KFeatureIdffContactsMycard ) )

        {

        iMyCardSupported = ETrue;

        }

    FeatureManager::UnInitializeLib();    

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

}

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

// Destructor

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

CPcsContactStore::~CPcsContactStore() 

{

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

	delete iContactViewBase;

	delete iSortOrder;

    delete iSimContactItems;   

	delete iWait;

	delete iUri;

	iTimer.Cancel();

    iTimer.Close();

	iFieldsToCache.Close();	

	iFs.Close();

	iInitialContactLinks.ResetAndDestroy();

	if(IsActive())

	{

		Deque();

	}

	delete iSortOrderMan;

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

}

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

// Handles addition/deletion/modification of contacts

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

void CPcsContactStore::HandleStoreEventL(MVPbkContactStore& aContactStore, 

                TVPbkContactStoreEvent aStoreEvent)

{

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

    PRINT2 ( _L("CPcsContactStore::HandleStoreEventL: URI=%S, event TVPbkContactStoreEventType::%d received"),

             &*iUri, aStoreEvent.iEventType);

    switch (aStoreEvent.iEventType) 

    {

		case TVPbkContactStoreEvent::EContactAdded:

        case TVPbkContactStoreEvent::EGroupAdded:

		{

		    // Observer will be notified once the cache update is complete

		    iOngoingCacheUpdate = ECacheUpdateContactAdded;

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

			break;

		}

        case TVPbkContactStoreEvent::EUnknownChanges:

        {

            iObserver->RemoveAll( *iUri );      

            // To indicate that contact view is not ready when unknown changes happens 

            iContactViewReady = EFalse;

            iContactViewBase->AddObserverL(*this);

            break;

        }

		case TVPbkContactStoreEvent::EContactDeleted:

        case TVPbkContactStoreEvent::EGroupDeleted:

		case TVPbkContactStoreEvent::EContactChanged:

		case TVPbkContactStoreEvent::EGroupChanged:

		{

			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 ) )

	        {

	            // Observer will be notified once the cache update is complete

	            iOngoingCacheUpdate = ECacheUpdateContactModified;

	            // Add the contact

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

	        }

	        else

	        {

	            // Inform observer immediately about contact removal

                iObserver->UpdateCachingStatus( *iUri, ECacheUpdateContactRemoved );

	        }

			break;

		}

	}

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

}

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

//  Returns ths database URI

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

TDesC& CPcsContactStore::GetStoreUri()

{

    return *iUri;

}

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

//  Check next state of state machine for contacts retrieval and perform

//  transition

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

void CPcsContactStore::CheckNextState()

{

    PRINT5 ( _L("CPcsContactStore::CheckNextState(state %d) %d:(%d..%d)/%d"),

             iNextState, iVPbkCallbackCount,

             iFetchBlockLowerNumber, iFetchBlockUpperNumber, iInitialContactCount );

    if ( iNextState == EComplete )

    {

        return;

    }

    // If during the caching of the contacts initially in the view we get some

    // contact events for other contact operations from the user, then it can

    // happen at the end of the caching process that iCallbackCount > iAllContactLinksCount.

    // We assume that it can never be that at the end of the caching it results

    // iCallbackCount < iAllContactLinksCount.

    // Check if caching is complete

    if( iFetchBlockUpperNumber == iInitialContactCount       // All contacts initially in the view were fetched

        && iVPbkCallbackCount >= iInitialContactCount )        // We got at least the same amount of callbacks

    {

        iObserver->UpdateCachingStatus(*iUri, ECachingComplete);

        iNextState = EComplete;

        IssueRequest( 0 );

    }

    // We could have a number of callbacks that is the same of the fetched contacts

    // from the view even before we get the all the callbacks for the fetched contacts.

    // This can happen for instance if a contact is added by the user.

    // With the following condition it will happen just that the fetching of more

    // contacts from the initial view is happening before all the callbacks for

    // those are received.

    else if ( iVPbkCallbackCount >= iFetchBlockUpperNumber ) // Fetch next block

    {

        iObserver->UpdateCachingStatus(*iUri, ECachingInProgress);

        iNextState = EFetchContactBlock;

        // Delay the next fetch since contact fetch is CPU intensive,

        // this will give other threads a chance to use CPU

        IssueRequest( KTimerInterval ); // 100 milliseconds

    }

    else

    {

    // Otherwise, just pass through.

    }

}

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

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

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

void CPcsContactStore::VPbkSingleContactOperationComplete(

        MVPbkContactOperationBase& aOperation, MVPbkStoreContact* aContact)

{

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

    // We get this incremented even during add/del of contacts during caching

    iVPbkCallbackCount++;

	// Handle the fetched contact....

	TRAPD(err, HandleRetrievedContactL(aContact) );

	if( err != KErrNone)

	{

		iObserver->UpdateCachingStatus(*iUri, err);

	}

	MVPbkContactOperationBase* Opr = &aOperation;

	if ( Opr )

	{

		delete Opr;

		Opr = NULL;

	}

	CheckNextState();

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

}

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

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

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

void CPcsContactStore::VPbkSingleContactOperationFailed(

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

{

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

  	iVPbkCallbackCount++;

	CheckNextState();

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

}

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

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

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

void CPcsContactStore::HandleRetrievedContactL(MVPbkStoreContact* aContact)

{    

    // Take the ownership

    aContact->PushL();

    if ( iMyCardSupported && IsMyCard( *aContact ) )

        {

        CleanupStack::PopAndDestroy( aContact );

        return;

        }

    // 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 )

    {

        CleanupStack::PopAndDestroy( aContact );

        return;

    }

	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("CPcsContactStore::HandleRetrievedContactL: SIM domain data received") );

        // Set the contact link 

        HBufC8* extnInfo = tmpLink->PackLC();

        phoneContact->SetDataExtension(extnInfo);

        CleanupStack::Pop( extnInfo );

        // Get the index of the SIM contact

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

		if ( KErrNotFound == tempIndex)

		    {

		    tempIndex = iSimContactItems->Count();

	        iSimContactItems->AppendL(tmpLink);

	        CleanupStack::Pop(); // tmpLink

	        }

		else

		    {

            CleanupStack::PopAndDestroy(); // tmpLink

		    }

	    //Create a dummy sim index and set it

	    TInt simIndex = CreateCacheIDfromSimArrayIndex(tempIndex);

	    phoneContact->SetId(simIndex);

	}

	else 

	{

	    // cntdb domain

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

		phoneContact->SetId(contactId);

		CleanupStack::PopAndDestroy(); // tmpLink

	}

	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 );

	    // Recover the URI

	    HBufC* storeUri = aContact->ParentStore().StoreProperties().Uri().UriDes().AllocL();

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

		iObserver->AddData(*storeUri, phoneContact);

		delete storeUri;

	}

	else

	{  

	    // Fetch the group name 

	    HBufC* groupName = myContactGroup->GroupLabel().AllocLC();

	    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);

            // 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

            // Recover the URI

            HBufC* storeUri = KVPbkDefaultGrpDbURI().AllocL();

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

            iObserver->AddData(*storeUri, phoneContact);

            delete storeUri;

	 	}

	    else

	    {

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

	    	delete phoneContact;

	    	phoneContact = NULL;

	    }

	    CleanupStack::PopAndDestroy( groupName );

	}

	delete converter;

	converter = NULL;

	CleanupStack::PopAndDestroy(aContact);

	// Inform observer if this contact addition was a result of contact store event.

	if ( iOngoingCacheUpdate == ECacheUpdateContactModified ||

	     iOngoingCacheUpdate == ECacheUpdateContactAdded )

	    {

        iObserver->UpdateCachingStatus( *iUri, iOngoingCacheUpdate );

        iOngoingCacheUpdate = ECachingComplete;

	    }

}

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

// 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);			

    }

}

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