/*

* Copyright (c) 2004-2006 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:  The CNssSpeechItemTrainer provides methods to train, save

*               and delete CNssSpeechItem objects in large quantities.

*

*/

/* Here is a state machine for training:

*

* Summary:

*

* Idle state

*     |

* Waiting state     <-------------------

*     |                                | (loop back to waiting state)

* ###################################  |

* # IF NEEDED: Create lexicon state #  |

* #            |                    #  |

* # IF NEEDED: Create grammar state #---

* #            |                    #

* #       Training state            #

* ###################################

*     |

* Idle state

*

*

*

* State: Idle state

* Event: A client calls TrainTextL, 

* Action:This induces a call to CNssSpeechItemTrainer::TrainTextDealyed().

*

*        The basic idea of _delayed_training_ is that several training calls

*        are piled up before taking action. When a large number of names is

*        trained at a time, the economies of scale are considerable.

*

*        So, TrainTextDelayed() adds the name to the to-be-trained list,

*        and starts a _delay_timer_. When this delay timer has finished, the

*        actual training starts.

* Transition: Idle state -> Waiting state

*

*

* State: Waiting state

* Event: A client calls TrainTextL.

* Action:The function adds the name to the to-be-trained list, and

*        resets the timer

*        (background: In contact synchronization via PC Suite, names are added

*         every 1/2 seconds. We want to keep piling the names  as long as

*         new names keep coming. Since we can't wait 50 seconds

*         before training, the only reasonable solution is to reset the timer

*         every time a new name arrives)

* Transition: Waiting state -> Waiting state

*

*

* State: Waiting state

* Event: Timer finishes doing time.

* Action:Check the preparations for training:

*         * Has the grammar for the context been created?

*         * Has the lexicon for the context been created?

* CASE: Preconditions OK

*       Action    : Send async AddVoiceTags call

*       Transition: Waiting state -> Training state

*

* State: Training state

* Event: Training finished

* Action: Save the newly created Rule IDs to the speech items.

*         Commit the database.

*         Make the callbacks (success or failure) to the client.

*

* Transition: Check if new names were piled during traning.

*         YES: Training state -> Waiting state

*         NO : Training state -> Idle state

*

*/

#include "srsfbldvariant.hrh"

#include "nssvascspeechitemtrainer.h"

#include "nssvasctrainingparameters.h"

#include "nssvascvasdatabase.h"

#include "nssvasmsavetagclient.h"

#include "nssvasmdeletetagclient.h"

#include "rubydebug.h"

#include <badesca.h>

#ifdef _DEBUG

    // Used in UDEB only

    _LIT( KSpeechItemTrainerPanic, "VasCSpeechItemTrainer" );

#endif  // _DEBUG

#define DEBUGPANIC User::Panic( KSpeechItemTrainerPanic, __LINE__ )

#define REACT( a, b ) if ( a != KErrNone ) { b; }

#define CHECK_NOT_NULL( a ) \

    if ( !(a) ) \

        { \

        return MNssSpeechItem::EVasTrainFailed; \

        }

#define ALLOWED_STATES( a, b, c ) \

    if ( iState != a && iState != b && iState != c ) \

        { \

        return MNssSpeechItem::EVasTrainFailed; \

        } 

// tags are buffered in the buffer that grows with this granularity

const TInt KTagBufferGranularity = 100;

// rule ids are buffered in the buffer that grows with this granularity

const TInt KRuleIdBufferGranularity = 50;

// tag ids are buffered in the buffer that grows with this granularity

const TInt KRemoveTagIdBufferGranularity = 50;

// Granularity for the array of words per sinde phrase

const TInt KSindeWordArrayGranularity = 2;

// Local function declarations

TInt EnforceRuleIdCountInvariant( RArray<TUint32>& aArray, TInt aCount );

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

// CNssSpeechItemTrainer::CNssSpeechItemTrainer

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CNssSpeechItemTrainer::CNssSpeechItemTrainer( CNssVASDatabase* aDatabase )

: iDatabase( aDatabase ),

  iSpeechItemBuffer       ( NULL ),

  iSpeechItemTrainingBuffer( NULL ),

  iGrammarIdBuffer        ( NULL ),

  iGrammarIdDeletingBuffer( NULL ),

  iTagBuffer(NULL)

    {

    // empty

    }

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

// CNssSpeechItemTrainer::ConstructL

// Symbian 2nd phase constructor can leave.

// This is overloaded function for SpeechItemTrainer from database

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

//

void CNssSpeechItemTrainer::ConstructL()

    {

    RUBY_DEBUG_BLOCK("CNssSpeechItemTrainer::ConstructL");

    iActionTracker = CNssTrainingActionTracker::NewL( *this );

    // Create buffer for grouping phrases in training

    iSpeechItemBuffer = new(ELeave)RPointerArray<CNssSpeechItem>;

    iSpeechItemTrainingBuffer = 0; // No name being currently trained.

    }

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

// CNssSpeechItemTrainer::NewL

// Two-phased constructor.

// This is for new SpeechItemTrainer

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

//

CNssSpeechItemTrainer* CNssSpeechItemTrainer::NewL( CNssVASDatabase* aDatabase )

    {

    RUBY_DEBUG_BLOCK( "CNssSpeechItemTrainer::NewL" );

    CNssSpeechItemTrainer* self = NewLC( aDatabase );

    CleanupStack::Pop( self );

    return self;

    }

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

// CNssSpeechItemTrainer::NewLC

// Two-phased constructor.

// This is overloaded function for SpeechItemTrainer from database

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

//

CNssSpeechItemTrainer* CNssSpeechItemTrainer::NewLC( CNssVASDatabase* aDatabase )

    {

    CNssSpeechItemTrainer* self

        = new (ELeave) CNssSpeechItemTrainer( aDatabase );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CNssSpeechItemTrainer::~CNssSpeechItemTrainer

// Delete the SpeechItemTrainer object and set the Portal's 

// state to Terminate.

// The Trainer does not delete the Portal, the Portal  

// deletes itself.

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

//

CNssSpeechItemTrainer::~CNssSpeechItemTrainer()

    {

    RUBY_DEBUG0( "CNssSpeechItemTrainer::~CNssSpeechItemTrainer" );

    delete iActionTracker;

    // Buffer for grouping the MNssSpeechItems for efficient training.

    if ( iSpeechItemBuffer )

        {

        iSpeechItemBuffer->Reset();

        delete iSpeechItemBuffer;

        }

    // Names, which are being trained by CSISpeechRecognitionUtility.

    if ( iSpeechItemTrainingBuffer )

        {

        iSpeechItemTrainingBuffer->Reset();

        delete iSpeechItemTrainingBuffer;

        }

    // This buffer is sent to SRS Utility. Contains: The recognition phrase split into subwords.

    iPhraseArray.ResetAndDestroy();

    // Training parameters

    delete iTrainingParams;

    // Context

    delete iContext;

    // Rule ID array. Return values from AddVoiceTags() are placed here.

    if ( iRuleIDArray )

        {

        iRuleIDArray->Close();

        delete iRuleIDArray;

        }

    if ( iDeleteRuleIDArray )

    	{

        RUBY_DEBUG0( "CNssSpeechItemTrainer::~CNssSpeechItemTrainer Deleting iDeleteRuleIDArray" );

    	iDeleteRuleIDArray->Close();

    	delete iDeleteRuleIDArray;

    	}

    // Handle to speech services

    if ( iSrsApi )

        {

        iSrsApi->CancelUtility();

        delete iSrsApi;

        iSrsApi = NULL;

        }

    // The tags to be saved: Owned by client

    // RPointerArray<CNssTag> *iTagBuffer;

    if ( iTagBuffer )

        {

        iTagBuffer->Reset();

        delete iTagBuffer;

        iTagBuffer = 0;

        }

    if ( iGrammarIdBuffer )

        {

        iGrammarIdBuffer->Reset();

        delete iGrammarIdBuffer;

        iGrammarIdBuffer = 0;

        }

    if ( iGrammarIdDeletingBuffer )

        {

        iGrammarIdDeletingBuffer->Reset();

        delete iGrammarIdDeletingBuffer;

        iGrammarIdDeletingBuffer = 0;

        }

    }

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

// CNssSpeechItemTrainer::RetrainTextDelayed

// Does delayed retraining.

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

//

MNssSpeechItem::TNssSpeechItemResult CNssSpeechItemTrainer::RetrainTextDelayed(

    MNssTrainTextEventHandler* aEventHandler,

	CNssTrainingParameters*    aTrainingParams,

    CNssSpeechItem&            aSpeechItem,

    CNssContext&               aContext)

    {

    RUBY_DEBUG0( "CNssSpeechItemTrainer::RetrainTextDelayed" );

    // Check parameters: 

    // callback 

    CHECK_NOT_NULL( aEventHandler );

    // phrase to be trained

    CHECK_NOT_NULL( aSpeechItem.Text().Length() );

    // Check state

    ALLOWED_STATES( EStateIdle, ERetrainStateWaiting, ERetrainStateRetraining );

    // Check event handler

    if ( !iTrainEventHandler )

        {

        iTrainEventHandler = aEventHandler;

        }

    else if ( iTrainEventHandler != aEventHandler )

        {

        return( MNssSpeechItem::EVasTrainFailed );

        }

    // The training parameters and the context 

    // must be the same for all in the buffer.

    TRAPD( error,

        if ( !CheckTrainingParametersL( aTrainingParams ) ||

             !CheckContext( aContext ) )

            {

            return( MNssSpeechItem::EVasTrainFailed );

            }

         );

    if ( error != KErrNone )

        {

        return MNssSpeechItem::EVasTrainFailed;

        }

    // Buffer the training request

    // Allocate buffer, if not done earlier

    if ( !SpeechItemBufferNeeded() )

        {

        return( MNssSpeechItem::EVasTrainFailed );

        }

    // If this is the first tag, save Lexicon ID and Grammar ID.

    if ( iSpeechItemBuffer->Count() == 0 )

        {

        iLexiconId = aContext.LexiconId();

        iGrammarId = aContext.GrammarId();

        }

    else

        {

        // The tags after the first one must have the same Gramamr ID & Lexicon ID.

        if ( iLexiconId != aContext.LexiconId() ||

            iGrammarId != aContext.GrammarId() )

            {

            return( MNssSpeechItem::EVasTrainFailed );

            }

        }

    // Add request to buffer

    TInt ret = iSpeechItemBuffer->Append( &aSpeechItem );

    if ( ret != KErrNone )

        {

        return( MNssSpeechItem::EVasTrainFailed );

        }

    // Restart timer. When the timer has waited for a defined period, the names

    // get retrained. Timer is reseted every time RetrainTextDelayed is called.

    //

    // Retraining in groups is more efficient. The delay ensures this grouping.

    switch( iState )

        {

        case ERetrainStateRetraining:

            // Wait for the retraining to finish before acting.

            break;

        case EStateIdle:

            SetState( ERetrainStateWaiting );

            RestartTimer();

            break;

        case ERetrainStateWaiting:

            RestartTimer();

            break;

        default:

            return( MNssSpeechItem::EVasTrainFailed );

        }

    return( MNssSpeechItem::EVasErrorNone );

    }

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

// CNssSpeechItemTrainer::SaveTagDelayed

// Does delayed saving.

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

//

TInt CNssSpeechItemTrainer::SaveTagDelayed(

    MNssSaveTagClient* aSaveTagClient,

    CNssTag& aTag )

    {

    RUBY_DEBUG0( "CNssSpeechItemTrainer::SaveTagDelayed" );

    // Check internal state: Must not be training

    if ( this->iState != EStateIdle &&

         this->iState != ESaveStateWaiting &&

         this->iState != ESaveStateSaving )

        {

        return( KErrNotReady );

        }

    // Check arguments

    if ( aSaveTagClient == 0  )

        {

        return KErrArgument;

        }

    if ( !((CNssSpeechItem*)aTag.SpeechItem())->Trained() )

        {

        return KErrNotReady;

        }

    // The event handler must be the same for all group-saved tags

    if ( !iSaveEventHandler )

        {

        iSaveEventHandler = aSaveTagClient;

        }

    else if ( aSaveTagClient != iSaveEventHandler )

        {

        return KErrArgument;

        }

    // Buffer the saving request

    // Allocate buffer, if not done earlier

    if ( !iTagBuffer )

        {

        iTagBuffer = new RPointerArray<CNssTag>( KTagBufferGranularity );

        if ( !iTagBuffer )

            {

            return KErrNoMemory;

            }

        }

    // Add request to buffer

    TInt ret = iTagBuffer->Append( &aTag );

    if ( ret != KErrNone )

        {

        return( ret );

        }

    // Restart timer. When the timer has waited for a defined period, the names

    // get saved. Timer is reseted every time SaveTagDelayed is called.

    //

    // Saving in groups is more efficient. The delay ensures this grouping.

    switch( iState )

        {

        case ESaveStateSaving:

            // Wait for the training to finish before acting.

            break;

        case EStateIdle:

            SetState( ESaveStateWaiting );

            RestartTimer();

            break;

        case ESaveStateWaiting:

            RestartTimer();

            break;

        default:

            return( KErrCorrupt );

        }

    return( KErrNone );

    }

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

// CNssSpeechItemTrainer::DeleteTagDelayed

// Does delayed deleting.

// (other items were commented in a header)

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

//

TInt CNssSpeechItemTrainer::DeleteTagDelayed(

    MNssDeleteTagClient* aDeleteTagClient,

    CNssTag& aTag )

    {

    RUBY_DEBUG0( "CNssSpeechItemTrainer::DeleteTagDelayed" );

    // Check internal state: Must not be doing something else

    ALLOWED_STATES( EStateIdle, EDeleteStateWaiting, EDeleteStateDeleting );

    // Check arguments

    CHECK_NOT_NULL( aDeleteTagClient );

    // The event handler must be the same for all group-deleted tags

    if ( !iDeleteEventHandler )

        {

        iDeleteEventHandler = aDeleteTagClient;

        }

    else if ( aDeleteTagClient != iDeleteEventHandler )

        {

        return KErrArgument;

        }

    // Buffer the deleting request

    // Allocate buffer, if not done earlier

    if ( !SpeechItemBufferNeeded() ||

         !GrammarIdBufferNeeded()  )

        {

        return( MNssSpeechItem::EVasTrainFailed );

        }

    // If this is the first tag, save the grammar id.

    if ( iSpeechItemBuffer->Count() == 0 )

        {

        iGrammarId = ((CNssContext*)aTag.Context())->GrammarId();

        if ( !iDeleteRuleIDArray ) 

        	{

        	iDeleteRuleIDArray = new RArray<TUint32>;

        	if( !iDeleteRuleIDArray ) 

        		{

        		return KErrNoMemory;

	        	}

        	// no deletion. iDeleteRuleIDArray might still be used

        	}

//        delete iDeleteRuleIDArray; // if any

//        iDeleteRuleIDArray = new RArray<TUint32>;

        }

    else