/*

* Copyright (c) 2010 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 "CIndexingWorker.h"

#include "CSearchDocument.h"

#include "CCPixIndexer.h"

#include <e32math.h>

CSearchDocument* GenerateDocumentLC( TInt aIndexAverageItems,  

									 const TDesC& aAppClass,

								     TDes& buf) 

	{

	TBuf<64> id;

	TInt deletionId = Math::Random() % aIndexAverageItems; 

	id.AppendNum( deletionId );

	CSearchDocument* doc = CSearchDocument::NewLC( id,

		                                           aAppClass );

	buf.Zero(); 

	TInt n = LogRand( KTermCountDeviation ) + 1; 

	for ( TInt i = 0; i < n; i++ ) 

		{

		buf.AppendNum( LogRand( KTermDeviation ) ); 

		if ( i + 1 < n ) 

			{

			buf.Append( _L( " " ) );

			}

		}

	doc->AddFieldL( KContentsField, buf, CDocumentField::EStoreYes | 

										  CDocumentField::EIndexTokenized | 

										  CDocumentField::EAggregateNo ); 

	doc->AddExcerptL( buf ); 

	return doc;

	}

//

// CIndexingWorker

//

CIndexingWorker::CIndexingWorker( TBool aDeletesEnabled, TInt aIndexAverageItems, TInt aSleep ) 

:	iStop( EFalse ),

 	iNextFreeUid( 0 ),

	iQualAppClass( 0 ),

	iAppClass( 0 ),

	iDeletesEnabled( aDeletesEnabled ), 

	iIndexAverageItems( aIndexAverageItems ),

	iSleep( aSleep ),

	iAdditions(), 

	iDeletes(), 

	iAdditionsMicroSeconds(), 

	iDeletesMicroSeconds()

	{

	}

CIndexingWorker* CIndexingWorker::NewL( const TDesC& aAppClass, TBool aDeletesEnabled, TInt aIndexAverageItems, TInt aSleep ) 

	{

	CIndexingWorker* self = new ( ELeave ) CIndexingWorker( aDeletesEnabled, aIndexAverageItems, aSleep ); 

	CleanupStack::PushL( self ); 

	self->ConstructL( aAppClass ); 

	CleanupStack::Pop( self ); 

	return self; 

	}

void CIndexingWorker::ConstructL( const TDesC& aQualAppClass ) 

	{

	CWorker::ConstructL(); 

	iQualAppClass = aQualAppClass.AllocL();

	iAppClass = aQualAppClass.Right( aQualAppClass.Length() - aQualAppClass.Find( _L( ":" ) ) - 1 ).AllocL();

	iName = HBufC::NewL( 512 );

	iName->Des().Append( _L( "indexer" ) ); 

	iName->Des().AppendNum( WorkerId() ); 

	iName->Des().Append( _L( "_") ); 

	iName->Des().Append( *iAppClass ); 

	}

CIndexingWorker::~CIndexingWorker() 

	{

	delete iName; 

	delete iAppClass;

	delete iQualAppClass; 

	}

void CIndexingWorker::DoPrepareL() 

	{

	iStop = EFalse; 

	}

void CIndexingWorker::DoCancel() 

	{

	iStop = ETrue; 

	}

void CIndexingWorker::DoRunL() 

	{

	RSearchServerSession session;

	User::LeaveIfError( session.Connect() );

	CleanupClosePushL( session ); 

	CCPixIndexer* indexer = CCPixIndexer::NewLC( session );

	indexer->OpenDatabaseL( *iQualAppClass );

	HBufC* buf = HBufC::NewLC( 1024*8 ); 

	while ( !iStop ) 

		{

		//

		// Following pieces of code will always add one item and after that 

		// it will delete an item at random. The average amount of items

		// released by the deletion part is the amount of documents n divided

		// by constant KAverageItemsPerIndex. This will keep the amount of

		// items around KAverageItemsPerIndex on average. 

		//

		// Add item

		TBuf<64> docuid; 

		TInt choose;  

		if ( iDeletesEnabled ) 

			{

			choose = Math::Random()%2;

			}

		else 

			{

			choose = 0; // always add 

			}

		switch ( choose ) 

			{

			case 0:

				//

				// Add item

				{

				TPtr pbuf( buf->Des() );

				CSearchDocument* doc = 

					GenerateDocumentLC( iIndexAverageItems, 

										*iAppClass, 

										pbuf );

				TTime before;

				before.UniversalTime();

				indexer->AddL( *doc ); 

				TTime after; 

				after.UniversalTime();

				iAdditions++; 

				iAdditionsMicroSeconds += after.MicroSecondsFrom(before).Int64(); 

				CleanupStack::PopAndDestroy( doc ); 

				}

				break;

			case 1: 

				//

				// Delete item

				{

				docuid.Zero(); 

				GetId( docuid ); 

				TTime before;

				before.UniversalTime();

				indexer->DeleteL( docuid ); 

				TTime after; 

				after.UniversalTime();

				iDeletes++; 

				iDeletesMicroSeconds += after.MicroSecondsFrom(before).Int64(); 

				}

				break;

			}

		Unlock(); 

		SleepRandom( iSleep );

		Lock(); 

		}

	CleanupStack::PopAndDestroy( buf ); 

	CleanupStack::PopAndDestroy( indexer ); 

	CleanupStack::PopAndDestroy(); // session 

	}

const TDesC& CIndexingWorker::Name() {

	return *iName; 

}

void CIndexingWorker::GetId(TDes& aId) 

	{

	TInt deletionId = Math::Random() % iIndexAverageItems; 

	aId.AppendNum( deletionId );

	}

TInt CIndexingWorker::ConsumeAdditions() 

	{

	TInt ret = iAdditions; 

	iAdditions = 0; 

	return ret; 

	}

TInt CIndexingWorker::ConsumeAdditionsMicroSeconds() 

	{

	TInt ret = iAdditionsMicroSeconds; 

	iAdditionsMicroSeconds = 0; 

	return ret; 

	}

TInt CIndexingWorker::ConsumeDeletes() 

	{

	TInt ret = iDeletes; 

	iDeletes = 0; 

	return ret; 

	}

TInt CIndexingWorker::ConsumeDeletesMicroSecond () 

	{

	TInt ret = iDeletesMicroSeconds; 

	iDeletesMicroSeconds = 0; 

	return ret; 

	}