/*

* 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:  A find operation that uses word parser function from client

*

*/

#include "CFindWithParserOperation.h"

#include "CContactStore.h"

#include "CFieldTypeMappings.h"

#include "CContactLink.h"

#include <MVPbkFieldType.h>

#include <MVPbkContactStoreInfo.h>

#include <CVPbkContactLinkArray.h>

#include <MVPbkContactFindFromStoresObserver.h>

#include <TVPbkWordParserCallbackParam.h>

#include <CVPbkContactFindPolicy.h>

#include <CVPbkSimContactBuf.h>

#include <CVPbkSimCntField.h>

#include <MVPbkSimCntStore.h>

namespace VPbkSimStore {

// Max amount of synchrnous contact reads from sim server

// at one step

const TInt KMaxContactReadInOneStep = 50;

const TInt KContinueIdle = 1;

const TInt KDontContinueIdle = 0;

// ======== MEMBER FUNCTIONS ========

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

// CFindWithParserOperation::CFindWithParserOperation

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

//

CFindWithParserOperation::CFindWithParserOperation( CContactStore& aStore,

        MVPbkContactFindFromStoresObserver& aObserver, 

        const TCallBack& aWordParserCallBack )

        :   iStore( aStore ),

            iSimStore( aStore.NativeStore() ),

            iObserver( aObserver ),

            iWordParserCallBack( aWordParserCallBack )

    {

    }

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

// CFindWithParserOperation::ConstructL

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

//

void CFindWithParserOperation::ConstructL( const MDesC16Array& aSearchStrings,

        const MVPbkFieldTypeList& aFieldTypes )

    {

    // Copy search strings

    const TInt stringCount = aSearchStrings.MdcaCount();

    TInt granularity = stringCount;

    if ( stringCount == 0 )

        {

        // default granularity

        granularity = 2;

        }

    iSearchStrings = new( ELeave ) CDesCArrayFlat( granularity );

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

        {

        iSearchStrings->AppendL( aSearchStrings.MdcaPoint( i ) );

        }

    // Convert field types

    const TInt fieldTypeCount = aFieldTypes.FieldTypeCount();

    for ( TInt j = 0; j < fieldTypeCount; ++j )

        {

        TVPbkSimCntFieldType simType = 

            iStore.FieldTypeMappings().Match( aFieldTypes.FieldTypeAt( j ) );

        if ( simType != EVPbkSimUnknownType )

            {

            iSimFieldTypes.AppendL( simType );

            }

        }

    iIdle = CIdle::NewL( CActive::EPriorityStandard );

    iResults = CVPbkContactLinkArray::NewL();

    iCurSimContact = CVPbkSimContactBuf::NewL( iSimStore );

    granularity = 4;

    iParsedWords = new( ELeave ) CDesCArrayFlat( granularity );

    // Assumes that find policy implementation exists

    iFindPolicy = CVPbkContactFindPolicy::NewL();

    }

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

// CFindWithParserOperation::NewL

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

//

CFindWithParserOperation* CFindWithParserOperation::NewL(

        CContactStore& aStore,

        const MDesC16Array& aSearchStrings,

        const MVPbkFieldTypeList& aFieldTypes,

        MVPbkContactFindFromStoresObserver& aObserver, 

        const TCallBack& aWordParserCallBack )

    {

    CFindWithParserOperation* self = new( ELeave ) CFindWithParserOperation( 

        aStore, aObserver, aWordParserCallBack );

    CleanupStack::PushL( self );

    self->ConstructL( aSearchStrings, aFieldTypes );

    CleanupStack::Pop( self );

    return self;

    }

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

// CFindWithParserOperation::~CFindWithParserOperation

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

//

CFindWithParserOperation::~CFindWithParserOperation()

    {

    Cancel();

    delete iFindPolicy;

    delete iParsedWords;

    delete iCurSimContact;

    delete iResults;

    delete iIdle;

    delete iSearchStrings;

    iSimFieldTypes.Close();

    }

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

// From class MVPbkContactOperation

// CFindWithParserOperation::StartL

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

//

void CFindWithParserOperation::StartL()

    {

    iTotalSimSlots = iStore.StoreInfo().MaxNumberOfContactsL();

    // SIM indexes start from 1

    iCurSimIndex = 1;

    if ( iSearchStrings->Count() == 0 || iSimFieldTypes.Count() == 0 )

        {

        // Set to zero so that find will stop immediately in callback

        iTotalSimSlots = 0;    

        }

    iIdle->Start( TCallBack( LoopContacts, this ) );

    }

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

// From class MVPbkContactOperation

// CFindWithParserOperation::Cancel

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

//

void CFindWithParserOperation::Cancel()

    {

    if ( iIdle )

        {

        iIdle->Cancel();

        }

    }

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

// CFindWithParserOperation::LoopContacts

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

//

TInt CFindWithParserOperation::LoopContacts( TAny* aThis )

    {

    CFindWithParserOperation* self = 

        static_cast<CFindWithParserOperation*>( aThis );

    TInt continueIdle = KDontContinueIdle;

    TRAPD( res, continueIdle = self->LoopContactsL() );

    if ( res != KErrNone )

        {

        self->HandleError( res );

        }

    return continueIdle;

    }

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

// CFindWithParserOperation::LoopContacts

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

//

TInt CFindWithParserOperation::LoopContactsL()

    {

    TInt contactsRead = 0;

    // Implementation comment: contact are read from server one contact

    // at a time. If this is too slow with big USIM cards then there are

    // couple of possibilities: 1) read many contacts in one request,

    // 2) do a find to SIM store that matches contacts that have search

    // strings anywhere in the field data. Then refine the result here.

    while ( iCurSimIndex <= iTotalSimSlots &&

            contactsRead <= KMaxContactReadInOneStep )

        {

        const TDesC8* etelCnt = iSimStore.AtL( iCurSimIndex );

        if ( etelCnt )

            {

            // reuse iCurSimContact

            iCurSimContact->SetL( *etelCnt );

            if ( IsCurrentContactMatchL() )

                {

                iResults->AppendL( 

                    CContactLink::NewLC( iStore, iCurSimIndex ) );

                CleanupStack::Pop(); // link

                }

            }

        ++iCurSimIndex;

        ++contactsRead;

        }

    if ( contactsRead == 0 )

        {

        // Results are ready.

        MVPbkContactLinkArray* results = iResults;

        iResults = NULL;

        iObserver.FindFromStoreSucceededL( iStore, results );

        iObserver.FindFromStoresOperationComplete();

        return KDontContinueIdle;

        }

    return KContinueIdle;

    }

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

// CFindWithParserOperation::IsCurrentContactMatchL

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

//    

TBool CFindWithParserOperation::IsCurrentContactMatchL()

    {

    TBool fieldMatched = EFalse;

    const TInt fieldCount = iCurSimContact->FieldCount();

    const TInt searchStringCount = iSearchStrings->Count();

    for ( TInt i = 0; i < fieldCount && !fieldMatched; ++i )

        {

        const CVPbkSimCntField& field = iCurSimContact->ConstFieldAt( i );

        // Check that is the type of the field in the given types

        if ( iSimFieldTypes.Find( field.Type() ) != KErrNotFound )

            {

            // Call clients parser function. It separates field data

            // into words and appends them into iParsedWords

            iParsedWords->Reset();

            TVPbkWordParserCallbackParam param( &field.Data(), iParsedWords );

            iWordParserCallBack.iFunction( &param );

            // All the search strings must match. If there are more

            // search strings than the words then it's not a match

            if ( searchStringCount <= iParsedWords->Count() )

                {

                TInt matchedWords = 0;

                for ( TInt j = 0; j < searchStringCount; ++j )

                    {

                    const TInt wordCount = iParsedWords->Count();

                    for ( TInt k = 0; k < wordCount; ++k )

                        {

                        if ( iFindPolicy->MatchRefineL( (*iParsedWords)[k], 

                            (*iSearchStrings)[j] ))

                            {

                            // Remove word that matched so that it's not

                            // matched again

                            iParsedWords->Delete( k );

                            ++matchedWords;

                            break;                           

                            }

                        }

                    }

                // If all words matched then the field data matched

                if ( matchedWords == searchStringCount )

                    {

                    fieldMatched = ETrue;

                    }

                }

            }

        }

    return fieldMatched;

    }

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

// CFindWithParserOperation::HandleError

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

//    

void CFindWithParserOperation::HandleError( TInt aError )

    {

    if ( aError != KErrNone )

        {

        iObserver.FindFromStoreFailed( iStore, aError );

        iObserver.FindFromStoresOperationComplete();

        }

    }

} // namespace VPbkSimStore