/*
* Copyright (c) 2004 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:  Algorithm manager for grammar handling algorihtms.
*
*/


// INCLUDE FILES
#include "devasrvmalgorithmmanager.h"
//#include "DevASRSrsAlgorithmManager.h"
#include <nssdevasr.h>
#include <nsssispeechrecognitiondatadevasr.h>
#include "rubydebug.h"


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

// -----------------------------------------------------------------------------
// CVMAlgorithmManager::CVMAlgorithmManager
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CVMAlgorithmManager::CVMAlgorithmManager( MDevASRObserver& aObserver,
                                          MVmAlgMgrObserver& aVmObserver )
                                        : iGrCompiler( NULL ), 
                                          iVocMan( NULL ), 
                                          iTtp( NULL ), 
                                          iObserver( aObserver ),
                                          iTtpState( ETtpStateUninitialized ),
                                          iGrState( EGrStateUninitialized ),
                                          iVmAlgObserver( aVmObserver )
    {
    // Nothing
    }


// -----------------------------------------------------------------------------
// CVMAlgorithmManager::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CVMAlgorithmManager::ConstructL()
    {
    RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::ConstructL()" );

    // TtpHwDevice
    iTtp = CASRSTtpHwDevice::NewL( *this );
    iTtp->InitializeL();
    iTtp->SetPhonemeNotationL( _L("NIPA8" ) );
    iTtpState = ETtpStateIdle;
    // Grammar compiler HW device
    iGrCompiler = CASRSGrCompilerHwDevice::NewL( *this );
    iGrCompiler->InitializeL();
    iGrState = EGrStateIdle;
    // VocManHwDevice
    iVocMan = CASRSVocManHwDevice::NewL();
    iVocMan->InitializeL();
    }


// -----------------------------------------------------------------------------
// CVMAlgorithmManager::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CVMAlgorithmManager* CVMAlgorithmManager::NewL( MDevASRObserver& aObserver, 
                                                MVmAlgMgrObserver& aVmObserver )
    {
    CVMAlgorithmManager* self = new( ELeave ) CVMAlgorithmManager( aObserver, aVmObserver );
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    
    return self;
    }


// -----------------------------------------------------------------------------
// CVMAlgorithmManager::~CVMAlgorithmManager
// Destructor
// -----------------------------------------------------------------------------
//
CVMAlgorithmManager::~CVMAlgorithmManager()
    {
    if ( iGrCompiler != NULL )
        {
        iGrCompiler->Clear();
        }
    delete iGrCompiler;
    iGrCompiler = NULL;
    if ( iVocMan != NULL )
        {
        iVocMan->Clear();
        }
    delete iVocMan;
    iVocMan = NULL;
    if ( iTtp != NULL )
        {
        iTtp->Clear();
        }
    delete iTtp;
    iTtp = NULL;
//    iDataArray.ResetAndDestroy();
    }


// -----------------------------------------------------------------------------
// CVMAlgorithmManager::AdaptVocabL
// Use CASRVocManHwDevice to adapt rule.
// -----------------------------------------------------------------------------
//
void CVMAlgorithmManager::AdaptVocabL( const CSIResultSet& aResultSet, 
                                       TInt aResultIndex )
    {
    RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::AdaptVocabL()" );

    const CSIResult& iCorrectResult = aResultSet.AtL( aResultIndex );

    TSIGrammarID grammarID( iCorrectResult.GrammarID() );
    TSIRuleID ruleID( iCorrectResult.RuleID() );
    TSIRuleVariantID ruleVariantID( iCorrectResult.RuleVariantID() );
    CSICompiledGrammar* siActiveGrammar = NULL;
    CSICompiledGrammar* siNonActiveGrammar = NULL;
    CSICompiledGrammar* siGrammar = NULL;
  
    TRAPD( error, iVmAlgObserver.GetGrammarL( grammarID, &siActiveGrammar, &siNonActiveGrammar ) );
    User::LeaveIfError( error );

    TInt index = 0;

    if ( siActiveGrammar != NULL )
        {
        siGrammar = siActiveGrammar;
        }
    else if ( siNonActiveGrammar != NULL )
        {
        siGrammar = siNonActiveGrammar;
        }
    else
        {
        User::Leave( KErrNotFound );	
        }
    
    index = siGrammar->Find( ruleID );
    User::LeaveIfError( index );
    CSIRule& rule = siGrammar->AtL( index );
    
    // Do the actual vocabulary adaptation using VocManHwDevice
    TRAP( error, iVocMan->AdaptL( ruleVariantID, rule ) );
    // Neglect possible error since it just might be due to the reason
    // that there are no proper parameters in place within the RuleVariants..
    }


// -----------------------------------------------------------------------------
// CVMAlgorithmManager::ComputeNewGrammarSizeL
// Use CASRVocManHwDevice to compute size.
// -----------------------------------------------------------------------------
//
void CVMAlgorithmManager::ComputeNewGrammarSizeL( const CSIGrammar& aGrammar, 
                                                  const TUint32 aTargetNRuleVariants, 
                                                  const TUint32 aMaxNRuleVariants, 
                                                  const RArray<TUint>& aNewRuleScores, 
                                                  RArray<TUint>& aNNeNRuleVariants, 
                                                  TUint32& aNPrune )
    {
    RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::ComputeNewGrammarSizeL()" );

    iVocMan->ComputeNRuleVariantsL( aGrammar, aTargetNRuleVariants, 
                                    aMaxNRuleVariants, aNewRuleScores, 
                                    aNNeNRuleVariants, aNPrune );
    }


// -----------------------------------------------------------------------------
// CVMAlgorithmManager::CompileGrammarL
// Compiles SI grammar.
// -----------------------------------------------------------------------------
//
void CVMAlgorithmManager::CompileGrammarL( CSICompiledGrammar& aGrammar/*, 
                                           CSIModelBank& aModelBank*/ )
    {
    RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::CompileGrammarL()" );

    if ( iGrState == EGrStateUninitialized )
        {
        User::Leave( KErrNotReady );
        }
    if ( iGrState == EGrStateBusyCombining || iGrState == EGrStateBusyCompiling )
        {
        User::Leave( KErrInUse );
        }

    iGrState = EGrStateBusyCompiling;

    iGrCompiler->CompileGrammarL( aGrammar/*, aModelBank*/ );
    }


// -----------------------------------------------------------------------------
// CVMAlgorithmManager::CombineGrammarL
// Combines a list of grammars.
// -----------------------------------------------------------------------------
//
void CVMAlgorithmManager::CombineGrammarL( const RPointerArray<CSICompiledGrammar>& aCompiledGrammars,
                                           const RPointerArray<TSIRuleVariantInfo>& aExcludedRules )
    {
    RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::CombineGrammarL()" );

    if ( iGrState == EGrStateUninitialized )
        {
        User::Leave( KErrNotReady );
        }
    if ( iGrState == EGrStateBusyCombining || iGrState == EGrStateBusyCompiling )
        {
        User::Leave( KErrInUse );
        }

    iGrState = EGrStateBusyCombining;

    iGrCompiler->CombineGrammarL( aCompiledGrammars, aExcludedRules );
    }

// -----------------------------------------------------------------------------
// CVMAlgorithmManager::PruneGrammar
// Use CASRVocManHwDevice to prune a grammar.
// -----------------------------------------------------------------------------
//
TBool CVMAlgorithmManager::PruneGrammar( const CSIGrammar& aGrammar, 
                                         const TUint32 aMinNumber, 
                                         RArray<TSIRuleVariantInfo>& aPrunedRuleVariants )
    {
    return iVocMan->Prune( aGrammar, aMinNumber, aPrunedRuleVariants );
    }


// -----------------------------------------------------------------------------
// CVMAlgorithmManager::ResolveResult
// Use CASRVocManHwDevice to resolve a result.
// -----------------------------------------------------------------------------
//
void CVMAlgorithmManager::ResolveResult( const RArray<TUint>& aNBestIDs,
                                         CSIResultSet& aSIResultSet,
                                         const RPointerArray<CSICompiledGrammar>& aSICompiledGrammar,
                                         const TDesC8& aCombinedData/*,
                                         CSIModelBank& iSIModelBank*/ )
    {
    iGrCompiler->ResolveResult( aNBestIDs, aSIResultSet,
                                aSICompiledGrammar, aCombinedData );
    }


// -----------------------------------------------------------------------------
// CVMAlgorithmManager::TrainFromText
// Use CVMAlgorithmManager to train from text.
// -----------------------------------------------------------------------------
//
void CVMAlgorithmManager::TrainFromTextL( CSITtpWordList& aWordList, 
                                          const RArray<TLanguage>& aDefaultLanguage, 
                                          const RArray<TUint32>& aMaxNPronunsForWord )
    {
    RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::TrainFromTextL()" );

    if ( iTtpState == ETtpStateUninitialized )
        {
        User::Leave( KErrNotReady );
        }
    if ( iTtpState == ETtpStateBusy )
        {
        User::Leave( KErrInUse );
        }

    iTtpState = ETtpStateBusy;
    
    TRAPD( error, iTtp->ConvertWordListL( aWordList, aDefaultLanguage, aMaxNPronunsForWord ) );
    if ( error != KErrNone )
        {
        iTtpState = ETtpStateIdle;
        User::Leave( error );
        }
    }


// -----------------------------------------------------------------------------
// CVMAlgorithmManager::Cancel
// Use CVMAlgorithmManager to cancel training.
// -----------------------------------------------------------------------------
//
void CVMAlgorithmManager::Cancel()
    {
    if ( iTtpState == ETtpStateBusy )
        {
        iTtp->CancelWordListConversion();
        }
    if ( iGrState == EGrStateBusyCompiling )
        {
        iGrCompiler->CancelCompilation();
        }
    if ( iGrState == EGrStateBusyCombining )
        {
        iGrCompiler->CancelCombination();
        }
    }


// -----------------------------------------------------------------------------
// GetEnginePropertiesL
// Returns properties of the underlying engines.
// -----------------------------------------------------------------------------
//
void CVMAlgorithmManager::GetEnginePropertiesL( const RArray<TInt>& /*aPropertyId*/, 
                                                RArray<TInt>& /*aPropertyValue*/ )
    {
    // Do nothing
    }

// -----------------------------------------------------------------------------
// CVMAlgorithmManager::LoadEnginePropertiesL
// Loads properties to engine, invalid IDs are neglected.
// -----------------------------------------------------------------------------
//
void CVMAlgorithmManager::LoadEnginePropertiesL( const RArray<TInt>& /*aParameterId*/,
                                                 const RArray<TInt>& /*aParameterValue*/ )
    {
    // Do nothing
    }

// -----------------------------------------------------------------------------
// MASRTtpHwDeviceObserver mixin begins
// -----------------------------------------------------------------------------


// -----------------------------------------------------------------------------
// CVMAlgorithmManager::MathdoConfigurationData
// 
// -----------------------------------------------------------------------------
//
HBufC8* CVMAlgorithmManager::MathdoConfigurationData( TUint32 aPackageType,
                                                      TUint32 aPackageID,
                                                      TUint32 aStartPosition,
                                                      TUint32 aEndPosition )
    {
    // Call DevASR observer
    return iObserver.ConfigurationData( aPackageType, aPackageID, 
                                        aStartPosition, aEndPosition );
    }
    

// -----------------------------------------------------------------------------
// CVMAlgorithmManager::MathdoWordListReady
// 
// -----------------------------------------------------------------------------
//
void CVMAlgorithmManager::MathdoWordListReady( const TInt aError )
    {
    RUBY_DEBUG0( "CVMAlgorithmManager::MathdoWordListReady()" );
    
    iTtpState = ETtpStateIdle;

    // Call DevASR observer
    iObserver.DevASREvent( EDevASRTrainFromText, aError );
    }
    

// -----------------------------------------------------------------------------
// MASRTtpHwDeviceObserver mixin ends
// -----------------------------------------------------------------------------


// -----------------------------------------------------------------------------
// MASRGrCompilerObserver mixin begins
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
// CVMAlgorithmManager::MghdoGrammarCompilerComplete
// 
// -----------------------------------------------------------------------------
//
void CVMAlgorithmManager::MghdoGrammarCompilerComplete( TInt aError )
    {
    iGrState = EGrStateIdle;
    // Forward callback to DevASR observer
    iObserver.DevASREvent( EDevASRGrammarCompile, aError );
    }

// -----------------------------------------------------------------------------
// CVMAlgorithmManager::MghdoGrammarCombinerComplete
// 
// -----------------------------------------------------------------------------
//
void CVMAlgorithmManager::MghdoGrammarCombinerComplete( HBufC8* aResult, 
                                                        TInt aError )
    {
    iGrState = EGrStateIdle;
    iVmAlgObserver.CombineComplete( aResult, aError );
    }

// -----------------------------------------------------------------------------
// CVMAlgorithmManager::MghdoSILexiconL
// 
// -----------------------------------------------------------------------------
//
CSILexicon* CVMAlgorithmManager::MghdoSILexiconL( TSILexiconID anID )
    {
    RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::MghdoSILexiconL()" );

    return iObserver.SILexiconL( anID );
    }

// -----------------------------------------------------------------------------
// CVMAlgorithmManager::MghdoConfigurationData
// 
// -----------------------------------------------------------------------------
//
HBufC8* CVMAlgorithmManager::MghdoConfigurationData( TUint32 aPackageType,
                                                     TUint32 aPackageID,
                                                     TUint32 aStartPosition,
                                                     TUint32 aEndPosition )
    {
    // Call DevASR observer
    return iObserver.ConfigurationData( aPackageType, aPackageID, 
                                        aStartPosition, aEndPosition );
    }


// -----------------------------------------------------------------------------
// MASRGrCompilerObserver mixin ends
// -----------------------------------------------------------------------------

// End of File