/*
* Copyright (c) 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:  
*
*/


// INCLUDE FILES
#include <StringLoader.h>
#include <centralrepository.h>

#include <nssvasctrainingparameters.h>

#include <srsfdomaincrkeys.h>

#include <vuivoicerecognition.rsg>

#include "vuicstate.h"
#include "vuicverificationtrainingstate.h"
#include "vuictutorialstate.h"
#include "vuicerrorstate.h"

#include "vuicdatastorage.h"

#include "vuicvoicerecogdialogimpl.h"

#include "rubydebug.h"

// Constants

static const TInt KCommandIds[] = 
    {
    R_QAN_VC_VERIFICATION_SELECT,
    R_QAN_VC_VERIFICATION_OTHER,
    R_QAN_VC_VERIFICATION_CANCEL
    };
    
// -----------------------------------------------------------------------------
// CVerificationTrainingState::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CVerificationTrainingState* CVerificationTrainingState::NewL( CDataStorage& aDataStorage, CUiModel& aUiModel )
    {
    CVerificationTrainingState* self = new (ELeave) CVerificationTrainingState( aDataStorage, aUiModel );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }       
    
// Destructor       
CVerificationTrainingState::~CVerificationTrainingState()
    {
    RUBY_DEBUG0( "CVerificationTrainingState::~CVerificationTrainingState START" );
    
    delete iVasDbManager;
    iContextManager = NULL;
    iTagManager = NULL;
    
    if ( iTags )
        {
        iTags->ResetAndDestroy();
        }
    delete iTags;
    
    delete iTrainingParameters;
    
    SaveLanguage();
    
    RUBY_DEBUG0( "CVerificationTrainingState::~CVerificationTrainingState EXIT" );
    }
    
// ---------------------------------------------------------
// CVerificationTrainingState::HandleEventL
// ---------------------------------------------------------
//       
void CVerificationTrainingState::HandleEventL( TInt aEvent )
    {
    RUBY_DEBUG_BLOCK( "CVerificationTrainingState::HandleEventL" );

    CState* nextState = NULL;
    
    switch( aEvent )
        {
        case KErrNone:
        
            if ( iInternalState == EStarted )
                {
                nextState = this;
                iInternalState = EContextDeleted;
                }
            else if ( iInternalState == EContextDeleted )
                {
                nextState = this;
                iInternalState = EContextReady;
                }
            else if ( iInternalState == EContextReady )
                {
                --iExpectedCallbacks;
                
                if ( iExpectedCallbacks == KErrNone )
                    {
                    nextState = this;
                    iInternalState = ECommandsTrained;
                    }
                }
            else
                {
                --iExpectedCallbacks;
                
                if ( iExpectedCallbacks == KErrNone )
                    {
                    nextState = CTutorialState::NewL( DataStorage(), UiModel() );
                    iInternalState = ECommandsSaved;
                    }
                }
            break;
            
        default:
            
            nextState = CErrorState::NewL( DataStorage(), UiModel(), aEvent );
            break;
        }

    DataStorage().VoiceRecognitionImpl()->ChangeState( nextState );
    }

// ---------------------------------------------------------
// CVerificationTrainingState::ExecuteL
// ---------------------------------------------------------
//       
void CVerificationTrainingState::ExecuteL()
    {
    RUBY_DEBUG_BLOCK( "CVerificationTrainingState::ExecuteL" );
    
    if ( iInternalState == ENotStarted )
        {
        iInternalState = EStarted;
        
        // Delete context if already exists
        if ( DataStorage().Context()->ContextName() == KVoiceVerificationContext )
            {
            if ( iContextManager->DeleteContext( DataStorage().VoiceRecognitionImpl(),
                                                 DataStorage().Context() ) != KErrNone )
                {
                RUBY_ERROR0( "CVerificationTrainingState::ExecuteL - DeleteContext call failed" );
                HandleEventL( KErrGeneral );
                }
            }
        else 
            {
            HandleEventL( KErrNone );
            }
        }
    else if ( iInternalState == EContextDeleted )
        {
        // Create new context
        MNssContext* vasContext = iContextManager->CreateContextL();
        DataStorage().SetContext( vasContext );
            
        vasContext->SetNameL( KVoiceVerificationContext );
        vasContext->SetGlobal( EFalse );
    
        if ( iContextManager->SaveContext( DataStorage().VoiceRecognitionImpl(),
                                           vasContext ) != KErrNone )
            {
            RUBY_ERROR0( "CVerificationTrainingState::ExecuteL - SaveContext call failed" );
            HandleEventL( KErrGeneral );
            }
        }
    else if ( iInternalState == EContextReady )
        { 
        TrainTagsL();        
        }
     else if ( iInternalState == ECommandsTrained )
        {
        SaveTagsL();
        }
    }

// ---------------------------------------------------------
// CVerificationTrainingState::CVerificationTrainingState
// ---------------------------------------------------------
//              
CVerificationTrainingState::CVerificationTrainingState( CDataStorage& aDataStorage, CUiModel& aUiModel )
 : CState( aDataStorage, aUiModel ), iInternalState( ENotStarted ), iTags(),
   iExpectedCallbacks( 0 )
    {
    }

// ---------------------------------------------------------
// CVerificationTrainingState::ConstructL
// ---------------------------------------------------------
//           
void CVerificationTrainingState::ConstructL()
    {
    RUBY_DEBUG_BLOCK( "CVerificationTrainingState::ConstructL" );
    
    CState::ConstructL();
    
    iVasDbManager = CNssVASDBMgr::NewL();
    iVasDbManager->InitializeL();
    iTagManager = iVasDbManager->GetTagMgr();
    iContextManager = iVasDbManager->GetContextMgr();   
    }
    
// ---------------------------------------------------------
// CVerificationTrainingState::CreateTagsL
// ---------------------------------------------------------
//  
void CVerificationTrainingState::CreateTagsL()
    {
    RUBY_DEBUG_BLOCK( "CVerificationTrainingState::CreateTagsL" );
    
    iTags = new ( ELeave ) RPointerArray<MNssTag>;
 
    for ( int i = 0; i < KVerificationCommands; ++i )
        {
        iTags->Append( iTagManager->CreateTagL( DataStorage().Context() ) );
        }
    }
    
// ---------------------------------------------------------
// CVerificationTrainingState::ConstructTrainingParametersL
// ---------------------------------------------------------
//  
void CVerificationTrainingState::ConstructTrainingParametersL()
    {
    RUBY_DEBUG_BLOCK( "CVerificationTrainingState::ConstructTrainingParametersL" );
    
    RArray<TLanguage>* languageArray = new ( ELeave ) RArray<TLanguage>;
    CleanupDeletePushL( languageArray ); // Protect [allocated on the heap] array itself
    CleanupClosePushL( *languageArray );  // Protect the array elements
    
    // Always generate a pronunciation in UI language
    User::LeaveIfError( languageArray->Append( User::Language() ) );
    
    iTrainingParameters = CNssTrainingParameters::NewL();
    
    iTrainingParameters->SetLanguages( languageArray );
    
    // For array elements pushed via CleanupClosePushL
    CleanupStack::Pop( languageArray );
    CleanupStack::Pop( languageArray ); 
    }
    
// ---------------------------------------------------------
// CVerificationTrainingState::TrainTagsL
// ---------------------------------------------------------
//  
void CVerificationTrainingState::TrainTagsL()
    {
    RUBY_DEBUG_BLOCK( "CVerificationTrainingState::TrainTagsL" );
    
    CreateTagsL();
    
    ConstructTrainingParametersL();
    
    iExpectedCallbacks = KVerificationCommands;
    
    for ( int i = 0; i < KVerificationCommands; ++i )
        {
        HBufC* text = StringLoader::LoadLC( KCommandIds[ i ] );    
        
        MNssSpeechItem* speechItem = static_cast<MNssTag*>( (*iTags)[ i ] )->SpeechItem();
        speechItem->SetTextL( *text );
        
        CleanupStack::PopAndDestroy( text );
        
        MNssRRD* rrd = static_cast<MNssTag*>( (*iTags)[ i ] )->RRD();
        
        rrd->IntArray()->AppendL( i );
            
        MNssSpeechItem::TNssSpeechItemResult result = 
		    speechItem->TrainTextL( DataStorage().VoiceRecognitionImpl(),
		                            iTrainingParameters );
    
        if ( result != MNssSpeechItem::EVasErrorNone )
            {
            RUBY_ERROR1( "CVerificationTrainingState::TrainTagsL - Training start failed with the nss code [%d]", result );

            HandleEventL( KErrGeneral );
            }
        }
    }
    
// ---------------------------------------------------------
// CVerificationTrainingState::SaveTagsL
// ---------------------------------------------------------
//  
void CVerificationTrainingState::SaveTagsL()
    {
    RUBY_DEBUG_BLOCK( "CVerificationTrainingState::SaveTagsL" );
    
    iExpectedCallbacks = KVerificationCommands;
    
    for ( int i = 0; i < KVerificationCommands; ++i )
        {
        TInt result = 
            iTagManager->SaveTag( DataStorage().VoiceRecognitionImpl(),
                                  static_cast<MNssTag*>( (*iTags)[ i ] ) );
        if ( result != KErrNone ) 
            {
            RUBY_ERROR1( "CVerificationTrainingState::SaveTagsL - Savetag start failed with the nss code [%d]", result );

            HandleEventL( KErrGeneral );
            }
        }
    }
        
// ---------------------------------------------------------
// CVerificationTrainingState::SaveLanguage
// ---------------------------------------------------------
//           
void CVerificationTrainingState::SaveLanguage()
    {
    RUBY_DEBUG0( "CVerificationTrainingState::SaveLanguage START" );
    
    TRAP_IGNORE(
        CRepository* client = CRepository::NewLC( KCRUidSRSFSettings );    
        client->Set( KSRSFVoiceUiLanguage, User::Language() );        
        CleanupStack::PopAndDestroy( client ) );
    
    RUBY_DEBUG0( "CVerificationTrainingState::SaveLanguage EXIT" );
    }
    
// End of File