/*

* 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 messagingplugin information search.

*

*/

// Includes

#include <smuthdr.h>

#include <mtclreg.h>	

#include <smsclnt.h>

#include <mmsvattachmentmanager.h> 

#include <searchtextsearcher.h>

#include <searchpluginobserver.h>

#include <msgentrydetails.h>

#include <SenduiMtmUids.h>

#include <btmsgtypeuid.h>

#include <utf.h>

#include <msvids.h>

#include <mtmuibas.h>

#include <mtmuidef.hrh>

#include <searchdocumentid.h>

#include <searchlightresult.h>

#include <searchcondition.h>

#include <searchpluginobserver.h>

#include <searchresult.h>

#include <searchcommon.h>

#include <searchsnippetcreator.h>

#include <searchtextsnippet.h>

//USER INCLUDES

#include "messagessearcher.h"

#include "messagessearchplugindefines.h"

// Definition of service

const TUid KMuiuMsgEditorServiceUid = { 0x101F8820 };

// Service types

const TInt KMsgServiceView = 0x00000001;

const TInt KMsgServiceEdit = 0x00000002;

//

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

// CMessagesSearcher::NewL()

// Symbian 1st phase constructor

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

//

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

								                    const CSearchCondition& aCondition, 

								                    const TUid& aPluginId,

								                    MSearchPluginObserver& aObserver )

{

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

    CleanupStack::PushL ( self );

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

    CleanupStack::Pop( self );

    return self;

}

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

// CMessagesSearcher::ConstructL()

// Symbian 2nd phase constructor

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

//   

void CMessagesSearcher::ConstructL( const RArray<TUid>& aContentIdArray, 

								    const CSearchCondition& aCondition,

								    MSearchPluginObserver& aObserver )

{

	iObserver = &aObserver;

	iSession = CMsvSession::OpenSyncL( *this );

	iMtmReg = CClientMtmRegistry::NewL( *iSession );

	iSmsMtm = STATIC_CAST ( CSmsClientMtm*, iMtmReg->NewMtmL( KUidMsgTypeSMS ) );

	iMmsMtm = STATIC_CAST ( CMmsClientMtm*, iMtmReg->NewMtmL( KUidMsgTypeMultimedia ) );

	SetPriority( EPriorityStandard );

	iTextSearcher = CSearchTextSearcher::NewL( *this );	

	iTextSearcher->SetParametersL( aCondition ); 

    iFolderEntry = NULL;

    iSearchNotCancelled = ETrue;

	User::LeaveIfError( iFs.Connect() );		// Connect to the filesystem:RFileSystem

	iHitFound = EFalse;

} // ConstructL

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

// CMessagesSearcher::CMessagesSearcher()

// C++ default constructor

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

//

CMessagesSearcher::CMessagesSearcher( const TUid&  aPluginId)

: iPluginId( aPluginId ),

CActive(EPriorityStandard)

{

    CActiveScheduler::Add( this );

}

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

// CMessagesSearcher::IsEntryDeleted()

// Checks the deltion of the entry before launching

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

//

TBool CMessagesSearcher::IsEntryDeleted( TMsvId& aMsgEntryId )

{

	if( iEntryDeleted )

	{	

		if( iEntryDeleted->Find( aMsgEntryId ) == KErrNotFound )

			return EFalse;

		else

			return ETrue;

	}

	else

	{

		return EFalse;

	}

}

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

// CMessagesSearcher::~CMessagesSearcher()

// Destructor

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

//

CMessagesSearcher::~CMessagesSearcher()

{	    

delete iMsvStore;

    iMsgDesCArray.ResetAndDestroy();

 	iHeavyResultsArray.ResetAndDestroy();  

 	if(iTextSearcher)

    {

    	delete iTextSearcher;

    	iTextSearcher = NULL;

    }

	if( iSmsMtm )

	    {

		delete iSmsMtm;

		iSmsMtm = NULL;

	    }

    if( iMmsMtm )

	    {

		delete iMmsMtm;

		iMmsMtm = NULL;

     	}

	if( iGenericMtm )

	{

		delete iGenericMtm;	

		iGenericMtm = NULL;

	}

    if( iSession )

	{

		delete iSession;

		iSession = NULL;	

	} 

    if( iEntryDeleted )

	    delete iEntryDeleted;

											// check for the members that are to be cleaned up...

}  // ~CMessagesSearcher

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

// CMessagesSearcher::Destroy()

// Search FW calls this function when it no longer needs this searcher.

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

//

void CMessagesSearcher::Destroy()

{

	iSearchNotCancelled = EFalse;

	if( IsActive() ) 

	{

		CActive::Cancel();

	}

	else

	{

	CleanUp();	

	}	

	delete this;

}

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

// CMessagesSearcher::CancelSearch()

// Cancels the search operation and then does the Cleanup stuff...

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

//

void CMessagesSearcher::CancelSearch()

{

	iSearchNotCancelled = EFalse;

	CleanUp();

}	

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

// CMessagesSearcher::DoCancel()

// Cancels the search.

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

//

void CMessagesSearcher::DoCancel()

{

CleanUp();

}

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

// CMessagesSearcher::Cleanup()

// For CleanUp resources

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

//

void CMessagesSearcher::CleanUp()

{                	

	if( iFolderEntry )

	{

		delete iFolderEntry;

		iFolderEntry = NULL;

	}

	if( iMessageEntry )

	{	

		delete iMessageEntry;

		iMessageEntry = NULL;

	}

	if( iMessageEntries )

	{

		delete iMessageEntries;	

		iMessageEntries = NULL;

	}

	iToBeSearchedFolders.Close();

	iFs.Close();

    iMtmArray.Reset();

   if(iCurrentTextBeingSearched)

     {

     delete iCurrentTextBeingSearched;

     iCurrentTextBeingSearched = NULL;

	 } 

	if(iSenderReciever)

	{

	   	delete iSenderReciever;

	   	iSenderReciever = NULL;

	   }

	iMsgEntriesInFoldersArray.Reset();

}

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

// Starts the search. Progress of the search is notified through aObserver. This call must be asynchronous.

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

//

void CMessagesSearcher::SearchL( )

{

	iHeavyResultsArray.ResetAndDestroy();

	iMsgDesCArray.ResetAndDestroy();

    CMessagesSearcher::SetTargetFolderL();

    iHitFound = EFalse;

	__ASSERT_ALWAYS( this != NULL, User::Panic( KMessagesSearchPlugIn,

            EMessageSearchPlugInWrongConstructionParameters ) );

	 if( iTextSearcher == NULL) 

		 {

		   ReportFinishedL( KErrNone );

		    return;

		 }

	// condition that checks if ready for searching and if there's 

	// any message entry in any of the desired folders. If no entries, no results found

	if(!PrepareForSearchL())

		{

		iObserver->SearchCompletedL( KErrNone, KErrNone );

		return;

		}

	else	

		{   

		//start the search

		iTotalNumOfItems = 0;

	    iStatusItemCounter = 1;

	    TRequestStatus* status = &iStatus;

	    User::RequestComplete( status, KErrNone );

	    SetActive();

		}

}

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

// CMessagesSearcher::NoEntriesInAllFolders()

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

//

TBool CMessagesSearcher::AnyEntriesInAllFolders()

{

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

{

	if(0 != iMsgEntriesInFoldersArray[i])	

		return ETrue;

}

return EFalse;

}

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

// CMessagesSearcher::GetResultsL( RPointerArray<CSearchResult> aResults )

// Gets the results got so far. A call to this function must flush the plugins internal buffer,

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

//

void CMessagesSearcher::GetResultsL( const RPointerArray<CSearchDocumentId>& aDocumentIdArray )

{

    RPointerArray<CSearchResult> aSearchResultArray;  

	TBufC8<KBufferLength> tempBuf(KText);

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

        {

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

            {

            	CSearchResult* tempHeavy =  	iHeavyResultsArray[j];

            if( (aDocumentIdArray[i]->DocumentId() == 

	    				 (iHeavyResultsArray[j]->Result()).DocumentId().DocumentId() ) && 

	    				 (aDocumentIdArray[i]->PluginId().iUid == iPluginId.iUid ) &&

	    				 (aDocumentIdArray[i]->RepositoryId() == KSearchCClassMessagesUid.iUid)

	    				 )

                {

               	if((&tempHeavy->Title() != NULL) && (&tempHeavy->Snippet() != NULL))

	                 {

	                        aSearchResultArray.Append( iHeavyResultsArray[j]);

	                        continue;	

	                 }

				if ( 0 < (*(iMsgDesCArray[j]->GetTitle())).Size() ) 	  

				{

					tempHeavy->SetTitleL( *(iMsgDesCArray[j]->GetTitle()));

				} 

					TInt KeyHitPos = iMsgDesCArray[j]->GetKeywordHitPosition();

					if(KeyHitPos != -1)

					{

					CSearchSnippetCreator* SnippetCreator = CSearchSnippetCreator::NewL();

			    	CleanupStack::PushL(SnippetCreator);

			    	CSearchTextSnippet* textSnippet = 

			    		SnippetCreator->CreateTextSnippetL(*( iMsgDesCArray[j]->GetBody()), KeyHitPos);

			    	tempHeavy->SetSnippetL( textSnippet->Snippet() );    		

			       	CleanupStack::PopAndDestroy(SnippetCreator);

			       	delete textSnippet;

			    	textSnippet = NULL;

					}

					else

					{

					HBufC8 * msgSnippet = HBufC8::NewL( iMsgDesCArray[j]->GetBody()->Des().Length() ) ;

                    TPtr8 ptr8(msgSnippet->Des()) ;

                    TPtr16 ptr16(iMsgDesCArray[j]->GetBody()->Des()) ;

	                CnvUtfConverter::ConvertFromUnicodeToUtf8( ptr8,ptr16 );	

                    if( msgSnippet->Length() == 0 ) 

                    {

                        _LIT8( KSpace, " " );

                        TBufC8<5>  tmpBufTitle( KSpace );

                        msgSnippet = tmpBufTitle.AllocL();

                    }	

					tempHeavy->SetSnippetL( *msgSnippet );  

					delete msgSnippet;

					msgSnippet= NULL;  		

					}

					tempHeavy->SetSnippetFormatL( tempBuf.Des());	

					aSearchResultArray.AppendL( tempHeavy );

                }

            }

        }

	iObserver->ResultsRetrieveCompleteL( aSearchResultArray );

    aSearchResultArray.Reset();

}	

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

// CMessagesSearcher::CancelResultsRetrieve( )

// Cancels the request for the result retrieval

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

//	

void CMessagesSearcher::CancelResultsRetrieve ( )

{

}

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

// CMessagesSearcher::SetTargetFolderL()

// Cancels the search.

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

//

void CMessagesSearcher::SetTargetFolderL()

{

iToBeSearchedFolders.Reset();

// Find all subfolders under the "Root" folder

CMsvEntry* rootEntry;

rootEntry = CMsvEntry::NewL( *iSession, KMsvRootIndexEntryIdValue,

TMsvSelectionOrdering( KMsvGroupByStandardFolders, EMsvSortByDetails, EFalse ) );

CleanupStack::PushL( rootEntry );

ListSubFoldersL( *rootEntry );

CleanupStack::PopAndDestroy( rootEntry );

}

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

// CMessagesSearcher::ListSubFoldersL()

// Checks all folders that need to be searched.  Folders to be searched are

//	set via SetTargetFolderL.

//	Calls AddFolderWithSubFoldersL to add the folder to the array of folders to be

//	searched.

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

//

void CMessagesSearcher::ListSubFoldersL(  const CMsvEntry& aFolderEntry )

{

// Only list "folder" children

CMsvEntrySelection* children = aFolderEntry.ChildrenL();

CleanupStack::PushL( children );

TInt sizeChildren = children->Count();

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

	{

	TMsvId& childId = ( *children )[i];

	const TMsvEntry& childEntry ( aFolderEntry.ChildDataL( childId ) );

	if ( ( childEntry.iType == KUidMsvServiceEntry ) ||

    	 ( childEntry.iType == KUidMsvFolderEntry ) )

		{

        AddFolderWithSubFoldersL( childId );

		}

	}

CleanupStack::PopAndDestroy( children );  

}

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

// CMessagesSearcher::AddFolderWithSubFoldersL(  )

// Will add the specified folder to the folder array to be searched.

// Subfolders of the specified folder are checked by calling ListSubFoldersL.

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

//

void CMessagesSearcher::AddFolderWithSubFoldersL( const TMsvId& aFolderId )

{

User::LeaveIfError( iToBeSearchedFolders.Append( aFolderId ) );

CMsvEntry* folderEntry = CMsvEntry::NewL( *iSession, aFolderId,

		TMsvSelectionOrdering( KMsvGroupByStandardFolders, EMsvSortByDetails, EFalse ) );

CleanupStack::PushL( folderEntry );

ListSubFoldersL( *folderEntry );

CleanupStack::PopAndDestroy( folderEntry );	// folderEntry

}

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

// Prepares the object for the search. MoveOnToNextMessageL is called

// to find the 1st message in the to be searched folders.

// Returns:  ETrue: When messages were found.

//          EFalse: No messages to search for found.	

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

//

TBool CMessagesSearcher::PrepareForSearchL()

{

iToBeSearchedFoldersIdx = 0;		// start searching on 1st folder item

iMessageEntriesIdx = 0;				// start searching on 1st message item

TInt foldersCount = iToBeSearchedFolders.Count();

if ( !foldersCount )

{

	return EFalse;

}

delete iFolderEntry;

iFolderEntry = NULL;

TMsvId& folderId = iToBeSearchedFolders[iToBeSearchedFoldersIdx];

TMsvSelectionOrdering order;

iFolderEntry = CMsvEntry::NewL( *iSession, folderId, order );

if(iMessageEntries)

    {