/*

* Copyright (c) 2006-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:   Plugin for contactsplugin information search.

*

*/

//SYSTEM INCLUDES

#include <utf.h>

#include <e32std.h>

#include <searchcondition.h>

#include <searchtextsearcher.h>

#include <searchdocumentid.h>

#include <searchlightresult.h>

#include <searchresult.h>

#include <searchcommon.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 <MVPbkContactFieldDateTimeData.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkContactLink.h>

#include <VPbkEng.rsg>

#include <VPbkContactStoreUris.h>

#include <TVPbkWordParserCallbackParam.h>

#include <TVPbkContactStoreUriPtr.h>

#include <searchpluginobserver.h>

#include <MVPbkContactViewBase.h>

#include <MVPbkContactStoreInfo.h>

#include <CVPbkContactViewDefinition.h>

#include <CVPbkSortOrder.h>

#include <MVPbkContactViewFiltering.h>

#include <barsc.h>

#include <barsread.h>

#include <contactssearchresource.rsg>

#include <bautils.h>

#include <data_caging_path_literals.hrh>

//USER INCLUDES

#include "contactssearcher.h"

#include "contactssearchplugindefines.h"

#include <featmgr.h>

//FORWARD DECLARATION

TInt VPbkParseDataL( TAny* aParam );

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

// 1st phase constructor

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

//

CContactsSearcher* CContactsSearcher::NewL( const RArray<TUid>& aContentIdArray, 

                                const CSearchCondition& aCondition, 

                                const TUid& aPluginId,

                                MSearchPluginObserver& aObserver )

    {

	CContactsSearcher* self = new ( ELeave ) CContactsSearcher( aPluginId );

	CleanupStack::PushL( self );

	self->ConstructL( aContentIdArray, aCondition,aObserver );

	CleanupStack::Pop( self );

	return self;

    }

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

// Destructor

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

//

CContactsSearcher::~CContactsSearcher() 

    {

    delete iFilterView;

    delete iContactViewBase;

	ifSession.Close();

	if( iCurrentlyOpenStores)

        {	

        // Close all the stores opened

        if(iContactManager)

        {

            TRAP_IGNORE(iContactManager->ContactStoresL().CloseAll( *this ));

        }

        if(iCurrentlyOpenStores)

        {

            const TInt count = iCurrentlyOpenStores->Count();

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

                {

                iCurrentlyOpenStores->Remove( (*iCurrentlyOpenStores)[i] );

                }

           delete iCurrentlyOpenStores;

		       iCurrentlyOpenStores = NULL;

        }

        }

    if ( iContactManager )

        {

 		delete iContactManager;

		iContactManager = NULL;	

        }

    if ( iTextSearcher )

        {

 		delete iTextSearcher;

		iTextSearcher = NULL;	

        }

    if(iAllContactItemsFromDb)

    {

        iAllContactItemsFromDb->ResetAndDestroy();   	

    	delete iAllContactItemsFromDb;

    	iAllContactItemsFromDb = NULL;

    }

    iContactArrayMapper.Reset();

    iCotnactDeletedList.Reset();

   	iHeavyResultsArray.ResetAndDestroy();

    FeatureManager::UnInitializeLib();

}

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

// A function that returns the contact link at given index of the iContactLinkArray

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

// 

//

MVPbkContactLink* CContactsSearcher::GetContactLinkAtIndexLC(TInt aIndex)

    {

    if(aIndex < iContactArrayMapper.Count()  && (EFalse == iCotnactDeletedList[aIndex] ))

        {

        if ( iAllContactItemsFromDb ) 

        	{

        	return iAllContactItemsFromDb->At(iContactArrayMapper[aIndex]).CloneLC();

        	}

        }

    else

        {

  	    return NULL;

        }

return NULL;

}

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

// Releases the resources

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

//

void CContactsSearcher::Destroy() 

    {

	if( IsActive() ) 

	    {

		CActive::Cancel();

	    }

	 else

	    {

	    CleanUp(); 	

	    }   

	    delete this; 

}

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

// Starts the search

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

//

void CContactsSearcher::SearchL()

    { 

    iSearchCancelled = EFalse;

   	iHeavyResultsArray.ResetAndDestroy();

   //	iContactLinkIndexArray.Reset();

    if(iAllContactItemsFromDb)

    {

	   iAllContactItemsFromDb->ResetAndDestroy();   

    }

    iContactManager->ContactStoresL().OpenAllL( *this );

    }

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

// Returns true,f search is in progress

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

//

TBool CContactsSearcher::IsSearching() 

    {

	return IsActive();

    }

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

// Cancels the search

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

//

void CContactsSearcher::CancelSearch() 

    {

    iSearchCancelled = ETrue;

	CActive::Cancel();

    }

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

// Gets the results 

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

//

void CContactsSearcher::GetResultsL( 

	const RPointerArray<CSearchDocumentId>& aDocumentIdArray )

    {

    //Check the aDocumentIdArray

    // For all the matching documentIds, fetch the corresponding

    // Heavy Result from iHeavyResultsArray and append it to heavyResultResponse

	RPointerArray<CSearchResult> heavyResultResponse; 

	//Search through the aDocumentIdArray, and select those heavy results

	// which belong to this plugin with the corresponding document id

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

	    {

	    TUid pluginId;

	    pluginId.iUid = aDocumentIdArray[j]->PluginId().iUid;

	    if ( (  pluginId.iUid == iPluginId.iUid ) &&

	         (aDocumentIdArray[j]->RepositoryId() == KSearchCClassContactsUid.iUid)

	       )  

	        {

            TInt myArrayIndex =aDocumentIdArray[j]->DocumentId()  ;

	        heavyResultResponse.AppendL(iHeavyResultsArray[myArrayIndex]);        

	        }             

	    }

	iObserver->ResultsRetrieveCompleteL( heavyResultResponse );

	heavyResultResponse.Reset();

    }

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

// Cancels the result retrieval

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

//

void CContactsSearcher::CancelResultsRetrieve() 

    {

    }

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

// Returns the search progress

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

//

void CContactsSearcher::GetSearchProgressL( TUid& /*aContentClassId*/, TInt& /*aCurrentDocument*/, TInt& /*aTotalDocuments*/ )

    {

    }

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

// Called when a result is found matching the search criteria

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

//

void CContactsSearcher::HitL( TInt /*aResult*/ ) 

    {

	// If search is still in progress, then process the search result

	if( !iSearchCancelled ) 

	    {

		CSearchDocumentId* searchDocId = NULL;

		TBuf8<KBufferLength> tempDes; 

	    // Set the repository id

		searchDocId = CSearchDocumentId::NewL( iTotalHits,iPluginId );

		searchDocId->SetRepositoryIdL( KSearchCClassContactsUid.iUid );

		CSearchLightResult* searchLightResult = CSearchLightResult::NewL( searchDocId );

        CleanupStack::PushL(searchLightResult);		

		searchLightResult->SetContentClassId( KSearchCClassContactsUid );

		searchLightResult->SetServiceId( KNullUid );

		 //HBufC8 *repositoryId = HBufC8::NewL( KBufferLength ) ;

         //repositoryId->Des().Append(KSpace);

	     searchDocId->SetRepositoryIdL( KSearchCClassContactsUid.iUid );

         //delete repositoryId; 

         //repositoryId = NULL;

		iContactArrayMapper.Append(iCurrentDatatBaseItemIndex - 1);

	    // Form the heavy result and append it to the iHeavyResultsArray

	    CSearchResult* tmpHeavyRes = NULL;

	    tmpHeavyRes = CSearchResult::NewL(searchLightResult);

	    CleanupStack::PushL(tmpHeavyRes);

	    //Set the Title for the heavy result

	    if ( iCurrentTitle )

	        {

		    tmpHeavyRes->SetTitleL( *iCurrentTitle );

	        delete iCurrentTitle; iCurrentTitle = NULL;

	        }

	    //Set the snippet for the heavy result

	    if ( iCurrentSnippet )

	        {

		    tmpHeavyRes->SetSnippetL(*iCurrentSnippet);

	        delete iCurrentSnippet;iCurrentSnippet = NULL;

	        }

	    // Check if the contact is a phone contact or a sim contact

	    // Accordingly set the folder id

	    TInt tempIndex = iContactArrayMapper[iTotalHits];

	    TVPbkContactStoreUriPtr uri = iAllContactItemsFromDb->At(tempIndex).ContactStore().StoreProperties().Uri();       

	    TVPbkContactStoreUriPtr phoneMemoryUri( VPbkContactStoreUris::DefaultCntDbUri() );

        if ( uri.Compare( phoneMemoryUri,TVPbkContactStoreUriPtr::EContactStoreUriStoreType) == 0 )

            {

             searchLightResult->SetContentFolderId( KSearchCFolderPhoneUid );  

            }

        else

            {

			searchLightResult->SetContentFolderId( KSearchCFolderSIMUid );         	

            }

	    //Set the SetSnippetFormatL

	    HBufC8 *snippetFormat = HBufC8::NewL( KBufferLength ) ;

	    snippetFormat->Des().Append(KSpace);

		tmpHeavyRes->SetSnippetFormatL( snippetFormat->Des() );

		delete snippetFormat; 

		snippetFormat = NULL;

	    //Append the heavy result to the iHeavyResultsArray

	    iHeavyResultsArray.AppendL(tmpHeavyRes);

		// Increment the iTotalHits and call ResultFoundL()

		iTotalHits++;              

	    iObserver->ResultFoundL( searchLightResult, iTotalHits, iTotalNumOfContactsSearched );

	   CleanupStack::Pop(tmpHeavyRes); 

	   CleanupStack::Pop(searchLightResult); 

	   }

}

HBufC8* CContactsSearcher::LaunchInfoL( const CSearchDocumentId& aDocumentID )

{

     if((aDocumentID.PluginId() == iPluginId) &&

       (aDocumentID.RepositoryId() == KSearchCClassContactsUid.iUid))

         {

           //HBufC *temp = HBufC::NewL(KMaxFileName) ;

           //TPtr docIdPtr = temp->Des();

           TInt myArrayIndex = aDocumentID.DocumentId();

		   //CnvUtfConverter::ConvertToUnicodeFromUtf8( docIdPtr,aDocumentID.DocumentId() );

		   //TLex16 myDocId(docIdPtr);

	       if(myArrayIndex < iContactArrayMapper.Count()  && (EFalse == iCotnactDeletedList[myArrayIndex] ))

	    	   {

                 if ( iAllContactItemsFromDb ) 

                	 {

	        	     MVPbkContactLink* launchContact = iAllContactItemsFromDb->At(iContactArrayMapper[myArrayIndex]).CloneLC();

	                 HBufC8 *launchInfo = launchContact->PackLC();

	                 CleanupStack::Pop();

	                 CleanupStack::Pop(); 

	                 delete launchContact;

	                 launchContact= NULL;

	                 return launchInfo;

	                 }

	    	   }

           else

        	   {

               User::Leave( KErrNotFound );

        	   }

         }

     return NULL;

}

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

// From class MVPbkContactStoreListObserver.

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

//

void CContactsSearcher::OpenComplete()

    {

     // If atleast one store is ready, 

     //       set iStoreReadyForAccessing = ETrue so that we can start the serach    

     // else

     //       Finish the search as no stores are available 

     if(iAtLeastOneStoreReady)

        {

        iStoreReadyForAccessing = ETrue;

        TRequestStatus* status = &iStatus;

    	User::RequestComplete( status, KErrNone );

    	SetActive();

        }

    else

        {

        //No stores available, so set the appropriate flag

        iNoContactStoreAvailable = ETrue;	

        }

    }

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

// From class MVPbkContactStoreObserver.

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

//

void CContactsSearcher::StoreReady(MVPbkContactStore& aStore)

    {

    // This function is called every time a store is ready to be 

    // accessed.

    const TDesC& uri = aStore.StoreProperties().Uri().UriDes();

    if ( !iCurrentlyOpenStores->IsIncluded( uri ) )

        {

        TRAP_IGNORE(iCurrentlyOpenStores->AppendL( uri ));

        }

    // We know that atleast one store is ready, so we can set this flag to ETrue

    iAtLeastOneStoreReady = ETrue;

    }

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

// From class MVPbkContactStoreObserver.

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

//

void CContactsSearcher::StoreUnavailable(

        MVPbkContactStore& /*aContactStore*/, TInt /*aReason*/)

    {

        //The store is not availble..so do notthing....

        //TRequestStatus* status = &iStatus;

        //User::RequestComplete( status, KErrNone );

     	//SetActive();

    }

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

// From class MVPbkContactStoreObserver.

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

//

void CContactsSearcher::HandleStoreEventL(MVPbkContactStore& aContactStore, 

                TVPbkContactStoreEvent aStoreEvent)

    {

    //if there is deletetion of contact, then we need to update

    MVPbkContactStore* storeInList = iContactManager->ContactStoresL().Find(aContactStore.StoreProperties().Uri());

	  TInt contactLocation = 0;

	if (storeInList !=NULL)

	{

		switch(aStoreEvent.iEventType)

		{

			case TVPbkContactStoreEvent::EContactDeleted:

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

			if( KErrNotFound != contactLocation)

			{

				TInt tempLoc = iContactArrayMapper.Find(contactLocation);

				if( KErrNotFound != tempLoc)

				{

					iCotnactDeletedList[tempLoc] = ETrue;

				}

			}

			break;

			default:

				break;

		}

	}

      // Dont't show store events

     TRequestStatus* status = &iStatus;

     User::RequestComplete( status, KErrNone );

     SetActive();

    }

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

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

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

//   

void CContactsSearcher::VPbkSingleContactOperationComplete(

        MVPbkContactOperationBase& /*aOperation*/, MVPbkStoreContact* aContact)

    {

    delete iVPbkOperation;

    iVPbkOperation = NULL;

    // Delete the retrieved link

    //iAllContactItemsFromDb->Delete( iCurrentDatatBaseItemIndex );

    // Handle the fetched contact....

    TRAPD( res, HandleRetrievedContactL( aContact ) );

    if ( res != KErrNone )

        {

        }

    if(iAllContactsSearched)

        {

        TRequestStatus* status = &iStatus;

	    User::RequestComplete( status, KErrNone );

	    SetActive();

        }