/*
* 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 "multithreadtester.h"
#include "RSearchServerSession.h"
#include "CCPixIndexer.h"
#include "CCPixSearcher.h"
#include "CSearchDocument.h"
#include <e32math.h>

#define KIndexingWorkerCount 4
#define KSearchingWorkerCount 16
#define KTermDeviation 10 // The bigger this word, the more different term 
#define KTermCountDeviation 10 // The bigger this word, the more terms per document
_LIT( KContentsField, "Contents " ); 

class CWorker : public CBase 
    {
public: 
    CWorker() 
    : iWorkerId( iNextFreeWorkerId++ ), 
      iActive( EFalse ), 
      iThread(), 
      iSemaphore()
        {
        }

    void ConstructL() 
        {
        User::LeaveIfError( iSemaphore.CreateLocal( 0 ) ); 
        }
    
    ~CWorker() 
        {
        if ( iActive ) 
            {
            Finish(); 
            }
        iSemaphore.Close(); 
        }
    
    TInt WorkerId() 
        {
        return iWorkerId; 
        }

    TInt Error() 
        {
        return iError; 
        }

    virtual const TDesC& Name() = 0;
    
    void StartL() 
        {
        TThreadFunction function = CWorker::ThreadFunction; 
        
        User::LeaveIfError( iThread.Create( Name(), function, 2048, 0, this ) ); 
         
        iActive = ETrue;
        iThread.Resume(); 
        // Go thread go
    }
    
    void Finish() 
        {
        iActive = EFalse;
        DoCancel(); 
        iSemaphore.Wait(); 
        iThread.Close(); 
        }
    
protected: 

    /**
     * For doing any required preparations in the original thread. 
     */
    virtual void DoPrepareL() = 0;
    virtual void DoCancel() = 0;
    virtual void DoRunL() = 0;

    void RunL() 
        {
        CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
        CleanupStack::PushL(scheduler);
        CActiveScheduler::Install(scheduler);

        TRAP(iError, DoRunL());
        iSemaphore.Signal(); 
        
        CleanupStack::PopAndDestroy(scheduler);
        }
    
public: 
    
    static TInt ThreadFunction(void *aThis) 
        {
        CTrapCleanup* cleanup = CTrapCleanup::New();
    
        TRAP_IGNORE
            ( 
            (reinterpret_cast<CWorker*>(aThis))->RunL();
            ); 

        delete cleanup;
        return KErrNone;
        }
    
private: 
    
    TInt iWorkerId;     
    TInt iError; 
    static TInt iNextFreeWorkerId;  
    TBool iActive; 
    RThread iThread; 
    RSemaphore iSemaphore; 
    };


TInt CWorker::iNextFreeWorkerId = 0;  

/**
 * Returns random numbers so, that small numbers
 * are most common. Used to approximate the distribution
 * of real world words. In the distribution the probability that n is 
 * one of the numbers following i is 9 times as probable as that n is i. 
 * 
 * NOTE: Doesn't really follow the real distribution of words, because
 *       the word distribution follows Zipf's law and is not logarithmic.
 *       These things won't probably matter too much in any case. 
 */
TInt LogRand( TInt aDeviation ) 
    {
    TInt rv = 0; 
    while ( Math::Random() % aDeviation ) rv++;
    return rv; 
    }

/**
 * Worker, which continuously adds items to the index. Operates on its own
 * thread. 
 */
class CIndexingWorker : public CWorker
    {
public:
    CIndexingWorker() 
    :   iStop( EFalse ),
        iNextFreeUid( 0 ),
        iQualAppClass( 0 ),
        iAppClass( 0 ) 
        {
        }
    
    static CIndexingWorker* NewL( const TDesC& aAppClass ) 
        {
        CIndexingWorker* self = new ( ELeave ) CIndexingWorker(); 
        CleanupStack::PushL( self ); 
        self->ConstructL( aAppClass ); 
        CleanupStack::Pop( self ); 
        return self; 
        }
     
    void 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() 
        {
        delete iName; 
        delete iAppClass;
        delete iQualAppClass; 
        }
    
public: // From Cworker

    virtual void DoPrepareL() {
        iStop = EFalse; 
    }

    virtual void DoCancel() {
        iStop = ETrue; 
    }
    
    virtual void 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 ) 
            {
            TBuf<64> docuid; 
            docuid.Append( _L("iw") ); 
            docuid.AppendNum( WorkerId() ); 
            docuid.Append( _L("_d") );  
            docuid.AppendNum( iNextFreeUid++ ); 

            CSearchDocument* doc = CSearchDocument::NewLC( docuid,
                                                           *iAppClass );
            
            buf->Des().Zero(); 
            TInt n = LogRand( KTermCountDeviation ) + 1; 
            for ( TInt i = 0; i < n; i++ ) 
                {
                buf->Des().AppendNum( LogRand( KTermDeviation ) ); 
                if ( i + 1 < n ) 
                    {
                    buf->Des().Append( _L( " " ) );
                    }
                }
                
            doc->AddFieldL( KContentsField, *buf, CDocumentField::EStoreYes | 
                                                  CDocumentField::EIndexTokenized | 
                                                  CDocumentField::EAggregateNo ); 
            doc->AddExcerptL( *buf ); 
            
            indexer->AddL( *doc ); 
            
            CleanupStack::PopAndDestroy( doc ); 
            }
        CleanupStack::PopAndDestroy( buf ); 
        CleanupStack::PopAndDestroy( indexer ); 
        CleanupStack::PopAndDestroy(); // session 
        }

    virtual const TDesC& Name() {
        return *iName; 
    }
    
private: 
    
    TBool iStop; 
    
    TInt iNextFreeUid; 

    HBufC* iQualAppClass;

    HBufC* iAppClass;

    HBufC* iName;

    };


/**
 * A worker that commits normal searches to the given  search domain. 
 * Worker operates within its own thread.  
 */
class CSearchingWorker : public CWorker
    {
public: 
    CSearchingWorker() 
    :   iStop( EFalse ),
        iAppClass( 0 ), 
        iName( 0 )
        {
        }
    
    static CSearchingWorker* NewL( const TDesC& aAppClass ) 
        {
        CSearchingWorker* self = new ( ELeave ) CSearchingWorker(); 
        CleanupStack::PushL( self ); 
        self->ConstructL( aAppClass ); 
        CleanupStack::Pop( self ); 
        return self; 
        }

    
    void ConstructL( const TDesC& aAppClass ) 
        {   
        CWorker::ConstructL(); 
        
        iAppClass = aAppClass.AllocL(); 

        iName = HBufC::NewL( 512 );
        iName->Des().Append( _L( "searcher") ); 
        iName->Des().AppendNum( WorkerId() ); 
/*      iName->Des().Append( _L( "_") ); 
        iName->Des().Append( aAppClass ); */
        }
    
    ~CSearchingWorker() 
        {
        delete iName;
        delete iAppClass; 
        }

public: // From Cworker

    virtual void DoPrepareL() 
        {
        iStop = EFalse; 
        }

    virtual void DoCancel() 
        {
        iStop = ETrue; 
        }
    
    virtual void DoRunL() 
        {
        RSearchServerSession session;
        User::LeaveIfError( session.Connect() );
        CleanupClosePushL( session ); 
        CCPixSearcher* searcher = CCPixSearcher::NewLC( session, KContentsField );
        
        searcher->OpenDatabaseL( *iAppClass );
        
        while ( !iStop ) 
            {
            TBuf<64> num; 
            num.AppendNum( LogRand( KTermDeviation ) );  
            TInt n = searcher->SearchL( num ); 
            for ( TInt i = 0; i < n; i++ ) 
                {
                TRAP_IGNORE( delete searcher->GetDocumentL( i++ ); ); 
                }
            }
        CleanupStack::PopAndDestroy( searcher ); // session
        CleanupStack::PopAndDestroy(); // session
        }
        
    virtual const TDesC& Name() 
        {
        return *iName; 
        }
    
private:
    
    TBool iStop; 
    HBufC* iAppClass; 
    HBufC* iName; 
    };


void CTestMultiThreading::setUp() 
    {
    }

void CTestMultiThreading::tearDown() 
    {
    }

void CTestMultiThreading::PrepareL() 
    {
    RSearchServerSession session;
    User::LeaveIfError( session.Connect() ); 
    CleanupClosePushL( session ); 
    
    // First database has one reader and one or two searchers, what 
    // is something that can be expected in the actual device
    User::LeaveIfError
        (
        session.DefineVolume( _L( "@df:root test expected" ), 
                              _L( "c:\\data\\indexing\\indexdb\\root\\test\\expected" ) )
        ); 
    
    // Second database has one reader and one or two searchers, what 
    // is quite uncommon example and mainly used to stress the search server
    User::LeaveIfError
        (
        session.DefineVolume( _L( "@df:root test busy" ),
                              _L( "c:\\data\\indexing\\indexdb\\root\\test\\busy" ) )
        );
        
    CCPixIndexer* indexer = CCPixIndexer::NewLC( session );
    indexer->OpenDatabaseL( _L( "@df:root test expected" ) );
    indexer->ResetL(); 
    indexer->OpenDatabaseL( _L( "@df:root test busy" ) );
    indexer->ResetL(); 
    CleanupStack::PopAndDestroy( indexer); 
    CleanupStack::PopAndDestroy(); // session  

    // 
    // Indexers
    // 
    
    // Indexer with one's own index
    iWorkers->Append( CIndexingWorker::NewL( _L( "@df:root test expected" ) ) );
    
    // 3 indexers in the same index
    iWorkers->Append( CIndexingWorker::NewL( _L( "@df:root test busy" ) ) );
    iWorkers->Append( CIndexingWorker::NewL( _L( "@df:root test busy" ) ) );
    iWorkers->Append( CIndexingWorker::NewL( _L( "@df:root test busy" ) ) );
    
    // = 4 indexers in total 
    
    // 
    // Searchers
    // 
    
    // Multisearcher
    iWorkers->Append( CSearchingWorker::NewL( _L( "root test" ) ) );

    // Search qualified index
    iWorkers->Append( CSearchingWorker::NewL( _L( "@df:root test expected") ) );

    // Search big the busy index
    iWorkers->Append( CSearchingWorker::NewL( _L( "@df:root test busy" ) ) );
    iWorkers->Append( CSearchingWorker::NewL( _L( "@df:root test busy" ) ) );
    iWorkers->Append( CSearchingWorker::NewL( _L( "root test busy" ) ) );
    
    // = 5 searchers in total
    }

void CTestMultiThreading::Wait(TInt aSeconds) 
    {
    RTimer timer; 
    TRequestStatus timerStatus; 
    timer.CreateLocal();        
    CleanupClosePushL( timer ); 
    
    timer.After( timerStatus, aSeconds * 1000 * 1000 ); 
    User::WaitForRequest(timerStatus); 
    
    CleanupStack::PopAndDestroy(); // timer 
    }

void CTestMultiThreading::RunL() 
    {
    for ( TInt i = 0; i < iWorkers->Count(); i++ ) 
        {
        (*iWorkers)[i]->StartL(); 
        }
    
    Wait( 5 ); // Wait for 5 seconds
    
    for ( TInt i = 0; i < iWorkers->Count(); i++ ) 
        {
        (*iWorkers)[i]->Finish(); 
        if ( (*iWorkers)[i]->Error() != KErrNone ) 
            {
            TBuf8<512> msg; 
            const TDesC& name = (*iWorkers)[i]->Name();
            for ( TInt c = 0; c < name.Length(); c++ ) {
                msg.Append( name[c] ); 
            }
            msg.Append( _L8( " failed with" ) );
            msg.AppendNum( (*iWorkers)[i]->Error() );
            //TS_FAIL( reinterpret_cast<const char*>( msg.PtrZ() ) ); 
            }
        }
    }

void CTestMultiThreading::Finish() 
    {
    iWorkers->ResetAndDestroy();
    }

void CTestMultiThreading::DoTestMultiThreadingL() 
    {
    iWorkers = new ( ELeave ) RPointerArray<CWorker>(); 
    CleanupStack::PushL( iWorkers ); 
    CleanupClosePushL( *iWorkers ); 
    PrepareL(); 
    TRAPD( err, RunL() ); 
    Finish(); 
    User::LeaveIfError( err ); 
    CleanupStack::PopAndDestroy( iWorkers ); 
    CleanupStack::PopAndDestroy(); // iWorkers  
    }