/*

* Copyright (c) 2003-2005 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:  CNssVasDatabase is responsible for the issuing of requests  to

*               to the VasDb server and returning the results to the VasDb Managers.

*

*/

#include "srsfbldvariant.hrh"

#include <e32base.h>

#include <e32test.h>

#include "nssvascvasdatabase.h"

#include "nssvascspeechitem.h"

#include "nssvascvasdbsrvdef.h"

#include "nssvastspeechitemconstant.h"

#include <f32file.h>

#include "rubydebug.h"

// Complementary macro for TRAPD:

// TRAPD( err, doSomething() );

// REACT( err, return( err ) );

#define REACT(a,b) if ( a < 0 ) {b;}

const TInt KTagRefListGranularity = 2;

const TInt KFetchedTagRefListGranularity = 50;

#ifdef _DEBUG

// used in UDEB macros only

_LIT( KVasDatabasePanic, "CNssVasDatabase.cpp" );

#endif // _DEBUG

// ============================ Methods ===============================

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

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

// might leave.

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

CNssVASDatabase::CNssVASDatabase( TInt /*aPriority*/ )

: iIsLocked( EFalse )

    {

    }

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

// CNssVasDatabase::NewLC

// Two-phased constructor.

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

//

CNssVASDatabase* CNssVASDatabase::NewLC( TInt aPriority )

    {

	CNssVASDatabase* self = new(ELeave)CNssVASDatabase( aPriority );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

    }

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

// CNssVasDatabase::NewL

// Two-phased constructor.

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

//

CNssVASDatabase* CNssVASDatabase::NewL( TInt aPriority )

    {

	CNssVASDatabase* self = NewLC( aPriority );

	CleanupStack::Pop( self );

	return self;

    }

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

// CNssVasDatabase::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CNssVASDatabase::ConstructL()

    {

    iContextBuilder         = CNssContextBuilder::NewL();

    iSpeechItemBuilder      = CNssSpeechItemBuilder::NewL( this );

    iVasDb                  = CNssVasDb::NewL( *iContextBuilder, 

                                               *iSpeechItemBuilder);

    iTNssTagRefList         = new(ELeave) TNssTagReferenceListArray( KTagRefListGranularity );

    }

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

// CNssVASDatabase::~CNssVASDatabase

// Destructor

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

CNssVASDatabase::~CNssVASDatabase()

    {

    RUBY_DEBUG0( "CNssVASDatabase::~CNssVASDatabase" ); 

    if ( iGrammarIdRuleIdPackage )

	    {

	    delete iGrammarIdRuleIdPackage;

        }

	if ( iSpeechItemBuilder )

	    {

	    delete iSpeechItemBuilder;

	    }

	if ( iVASDBEventMonitor )

	    {

	    delete iVASDBEventMonitor;

	    }

	if ( iTNssTagRefList )

	    {

        iTNssTagRefList->Reset();

	    delete iTNssTagRefList;

	    }

	if ( iVasDb )

	    {

	    delete iVasDb;

	    }

	if ( iContextBuilder )

	    {

	    delete iContextBuilder;

        }	    

    }

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

// RNssVasDbSession::OpenDatabase

// Method to open the database.

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

//

TInt CNssVASDatabase::OpenDatabase()

    {

    if ( iConnected )

        {

        iConnected++;

        return KErrDbAlreadyOpen;

        }

    TRAPD( error, iVasDb->OpenDatabaseL() ); 

    if ( error == KErrNone )

        {

        iConnected++;

        }

    return error;

    }

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

// RNssVasDbSession::CloseDatabase

// Method to close the database.

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

//

void CNssVASDatabase::CloseDatabase()

    {

    // Check if already closed (or never opened)

    if ( iConnected > 0 )

        {

        // Some other VAS instance in the same thread may be using the database.

        iConnected--;

        // If not, close it.

        if ( iConnected <= 0 )

            {

            iVasDb->CloseDatabase();

            }

        }

    }

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

// CNssVasDatabase::CreateDb

// Method to create vas database

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

TInt CNssVASDatabase::CreateDb()

    {

    TRAPD( error, iVasDb->CreateDatabaseL() );

    return error;

    }

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

// CNssVasDatabase::StartMonitoringDatabaseL

// Method to start monitoring changes to vas database

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

void CNssVASDatabase::StartMonitoringDatabaseL()

    {

    //iVASDBEventMonitor = CNssVASDBEventMonitor::NewL();

    }

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

// CNssVasDatabase::AddObserverL

// Method to add an observer of the vas database

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

void CNssVASDatabase::AddObserverL( MNssVASDatabaseObserver* /*aObserver*/ )

    {

    User::Leave( KErrNotSupported );

    }

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

// CNssVasDatabase::RemoveObserverL

// Method to remove an observer of the vas database

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

TInt CNssVASDatabase::RemoveObserver( MNssVASDatabaseObserver* /*aObserver*/ )

    {

	return KErrNotFound;

    }

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

// CNssVasDatabase::ModelBankAndLexiconExist

// Method to determine if modelbank and lexicon ids exist.

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

TBool CNssVASDatabase::ModelBankAndLexiconExist( TUint32 &aModelBankId, TUint32 &aLexiconId )

    {

    TBool ret = EFalse;

    TRAPD( err, ret = iVasDb->GetModelBankIdLexiconIdL( aModelBankId, aLexiconId ) );

    // To remove warning

    if ( err != KErrNone )

        {

        }

    return ret;

    }

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

//CNssVasDatabase::TagExist

//Method to determine if tags exist for a context.

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

TBool CNssVASDatabase::TagExist( CNssContext* aContext )

    {

    TBool ret( EFalse );

    if ( aContext->ContextId() != KNssVASDbDefaultValue )

        {

        TRAPD( error, ret = iVasDb->TagExistL( aContext->ContextId() ) );

        REACT( error, ret = EFalse );

        } 

    else

        {

        RUBY_DEBUG0( "CNssVASDatabase::TagExist ERROR:Unsaved context" );

        }

    return ret;

    }

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

//CNssVasDatabase::TagCount

//Method to get the number of tags for a context.

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

TInt CNssVASDatabase::TagCount( CNssContext* aContext )

    {

    TInt ret( KErrNotFound );

    if ( aContext->ContextId() != KNssVASDbDefaultValue )

        {

        TRAPD( error, ret = iVasDb->TagCountL( aContext->ContextId() ) );

        // To remove warning

        if ( error != KErrNone )

            {

            }

        }

    return ret;

    }

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

// CNssVasDatabase::SaveContext

// Method to save a context 

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

TInt CNssVASDatabase::SaveContext( CNssContext* aContext, TInt& aContextId )

    {

    TInt ret = KErrNone;

    aContextId = aContext->ContextId();

    if ( aContext->ContextId() == KNssVASDbDefaultValue )

        {

        TRAP( ret, iVasDb->SaveContextL( *aContext, aContextId ) );

        }

    else

        {

        TRAP( ret, iVasDb->UpdateContextL( *aContext ) );

        }

    return ret;  

    }

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

// CNssVasDatabase::SaveContextClientData

// Method to save the clientdata of a context 

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

TInt CNssVASDatabase::SaveContextClientData( CNssContext* aContext )

    {

    TRAPD( error, iVasDb->UpdateContextClientDataL( *aContext ) );

    return error;

    }

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

// CNssVasDatabase::GetContext

// Method to get a context by name

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

CArrayPtrFlat<CNssContext>* CNssVASDatabase::GetContext( const TDesC& aName )

    {

    CArrayPtrFlat<CNssContext>* result = NULL;

    TRAPD( error, result = iVasDb->GetContextByNameL( aName ) );

    // To remove warning

    if ( error != KErrNone )

        {

        }

    return result;

    }

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

// CNssVasDatabase::GetGlobalContexts

// Method to get all global contexts 

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

CArrayPtrFlat<CNssContext>* CNssVASDatabase::GetGlobalContexts()

    {

    CArrayPtrFlat<CNssContext>* result = NULL;

    TRAPD( error, result = iVasDb->GetGlobalContexts() );

    // To remove warning

    if ( error != KErrNone )

        {

        }

    return( result );

    }

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

// CNssVasDatabase::GetAllContexts

// Method to get all contexts 

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

//

CArrayPtrFlat<CNssContext>* CNssVASDatabase::GetAllContexts()

    {

    CArrayPtrFlat<CNssContext>* result = NULL;

    TRAPD( error, result = iVasDb->GetAllContexts() );

    // To remove warning

    if ( error != KErrNone )

        {

        }

    return result;

    }

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

// CNssVasDatabase::SaveTag

// Method to save a tag 

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

TInt CNssVASDatabase::SaveTag( CNssTag* aTag, TInt& aNewId )

    {

    TInt ret = KErrNone;

    if ( aTag->TagId() == KNssVASDbDefaultValue )

        {

        TRAP( ret, iVasDb->SaveTagL( *aTag, aNewId ) );

        }

    else

        {

        // Used to call RNssVasDbSession::UpdateTag

        // which returned KErrNotSupported

        ret = KErrNotSupported;

        }

    return ret;

    }

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

// CNssVasDatabase::DeleteTag

// Method to delete several tags 

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

//

TInt CNssVASDatabase::DeleteTags( const RArray<TUint32>& aTagIdArray )

    {

    TRAPD( error, iVasDb->DeleteTagsL( aTagIdArray ) );

    return error;

    }

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

// CNssVasDatabase::SaveTag

// Method to save several tags 

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

//

TInt CNssVASDatabase::SaveTags( RPointerArray<CNssTag>* aTagArray )

    {

    RUBY_DEBUG0("CNssVASDatabase::SaveTags");

    RArray<TInt> tagIdArray;

    TInt arrayCount = aTagArray ? aTagArray->Count() : 0;

    if( arrayCount == 0 )

        {

        arrayCount++;

        }

    CArrayPtrFlat<CNssTag>* ctagArray = new CArrayPtrFlat<CNssTag>( arrayCount );

    for( TInt i( 0 ); i < aTagArray->Count(); i++ )

        {

        TRAPD( error, ctagArray->AppendL( (*aTagArray)[i] ) );

        if( error != KErrNone )

            {

            delete ctagArray;

            return error;

            }

        }

    TRAPD( error, iVasDb->SaveTagsL( ctagArray, tagIdArray ) );

    if( error == KErrNone ) 

    	{

    	RUBY_ASSERT_DEBUG( ctagArray->Count() == tagIdArray.Count(), 

    	                   User::Panic( KVasDatabasePanic, __LINE__ ) );

    	for ( TInt k( 0 ); k < ctagArray->Count(); k++ )

        	{

        	(*aTagArray)[k]->SetTagId( tagIdArray[k] );

        	}

    	}

    else 

    	{

    	// iSess->SaveTags failed

    	/** @todo Higher level handler should display some "No memory" label if possible 

    	Or should we do it here? */

    	}

    delete ctagArray;

    tagIdArray.Close();

    return error;

    }

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

// CNssVasDatabase::GetTag

// Method to get a tag by name

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

MNssTagListArray* CNssVASDatabase::GetTag( const TDesC& aName )

    {

    CArrayPtrFlat<CNssTag>* result = NULL;

    TRAPD( error, result = iVasDb->GetTagL( aName ) );

    // To remove warning

    if ( error != KErrNone )

        {

        }

    CArrayPtrFlat<MNssTag>* array = NULL;

    TInt arrayCount = result ? result->Count() : 0;

    if( arrayCount == 0 )

        {

        arrayCount++;

        }

    array = new CArrayPtrFlat<MNssTag>( arrayCount );

    if( !array )

        {

        return NULL;

        }

    if( result )

        {

        for( TInt i( 0 ); i < result->Count(); i++ )

            {

            TRAP( error, array->AppendL( result->At( i ) ) );

            if( error != KErrNone )

                {

                return NULL;

                }

            }

        result->Reset();

        delete result;   

        }

    return array;

    }

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

// CNssVasDatabase::GetTag

// Method to get a tag by context and name

// Not fully implemented.

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

MNssTagListArray* CNssVASDatabase::GetTag(CNssContext* /*aContext*/,const TDesC& aName)

    {

    return GetTag(aName);

    }

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

// CNssVasDatabase::GetTag

// Method to get a tag by context.

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

//

CArrayPtrFlat<MNssTag>* CNssVASDatabase::GetTag( CNssContext* aContext )

    {

    CArrayPtrFlat<CNssTag>* result = NULL;

    TRAPD( error, result =  iVasDb->GetTagL( *aContext ) );

    // To remove warning

    if ( error != KErrNone )

        {

        }

    CArrayPtrFlat<MNssTag>* array = NULL;

    if( result )

        {

        array = new CArrayPtrFlat<MNssTag>( result->Count() );