/*

* 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:  Implementation of VAS database handling

*

*/

#include "nssvascvasdb.h"

#include <e32test.h>

#include <e32std.h>

#include <e32svr.h>

#include "rubydebug.h"

#include "nssvascoreconstant.h"

#include "nssvascrrd.h"

#include "nssvasbackupobserver.h"

// CONSTANTS

// Name of the DB lock mutex

_LIT( KLockMutex, "VASDATABASE" );

#ifdef _DEBUG

// used in UDEB macros only

_LIT( KVasDbPanic, "VasCNssVasDb.cpp");

#endif // _UDEB

// Maximum size of tag array

static const TInt KMaxTagArraySize = 50;

const TInt KContextListGranularity = 5;

const TInt KSqlStatementmaxLength = 120;

// MACROS

// Complementary macro for TRAPD

#define REACT( err, codeblock ) if ( err != KErrNone ) { codeblock; }

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

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

// CNssVasDb::NewL

// 2-level constructor

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

//

CNssVasDb* CNssVasDb::NewL( CNssContextBuilder& contextBuilder,

	                        CNssSpeechItemBuilder& speechItemBuilder )

    {

    RUBY_DEBUG_BLOCK( "CNssVasDb::NewL" );

    CNssVasDb* self = new(ELeave) CNssVasDb( contextBuilder,

                                             speechItemBuilder );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CNssVasDb::~CNssVasDb

// Standard C++ destructor

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

//

CNssVasDb::~CNssVasDb()

    {

    RUBY_DEBUG0( "CNssVasDb::~CNssVasDb" );

    if ( iLocked )

        {

        RUBY_DEBUG0( "Signalling mutex in CNssVasDb::~CNssVasDb" );

        iMutex.Signal();

        }

    else

        {

        RUBY_DEBUG0( "NOT signalling mutex in CNssVasDb::~CNssVasDb iLocked = EFalse" );

        }

    if ( iClientHasOpenedDatabase )

        {

        CloseDatabase();

        }

    iMutex.Close();

    delete iBackupObserver;

    iCriticalSection.Close();

    RUBY_DEBUG0( "CNssVasDb::~CNssVasDb Mutex handle closed" );

    }

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

// CNssVasDb::CNssVasDb

// Standard C++ contructor

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

//

CNssVasDb::CNssVasDb( CNssContextBuilder& aContextBuilder,

	                  CNssSpeechItemBuilder& aSpeechItemBuilder )

: iClientHasOpenedDatabase( EFalse ),

  iLocked( EFalse ),

  iContextBuilder( aContextBuilder ),

  iSpeechItemBuilder( aSpeechItemBuilder )

    {

    // empty

    }

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

// CNssVasDb::ConstructL

// Symbian second constructor.

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

//

void CNssVasDb::ConstructL()

    {

    TInt err = iMutex.OpenGlobal( KLockMutex );

    if ( err != KErrNone )

        {

        RUBY_DEBUG0( "CNssVasDb::ConstructL Creating new global mutex" );

        iMutex.CreateGlobal( KLockMutex );

        }

    else

        {

        RUBY_DEBUG0( "CNssVasDb::ConstructL Using existing global mutex" );

        }

    iCriticalSection.CreateLocal();

    iBackupObserver = CNssVasBackupObserver::NewL( *this );

    }

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

// CNssVasDb::RollbackCleanupFunction

// This function is used to form iRollbackCleanupItem. When this item is

// popped from the cleanup stack, it makes a rollback on VAS DB.

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

//

void CNssVasDb::RollbackCleanupFunction( TAny* aArg )

    {

    RUBY_DEBUG0( "CNssVasDb::RollbackCleanupFunction" );

    CNssVasDb* me = (CNssVasDb*)aArg;

    me->RollbackTransaction();

    }

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

// CNssVasDb::CreateDatabaseL

// Creates a new database.

// from a resource file.

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

//

void CNssVasDb::CreateDatabaseL()

    {

    User::LeaveIfError( iDbSession.Connect() );

    CleanupClosePushL( iDbSession );

    iDbcreator.CreateVasDatabaseL( iDbSession );

    CleanupStack::PopAndDestroy( &iDbSession );

    }

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

// CNssVasDb::OpenDatabaseL

// Opens the database. Reads the path and file name of the database

// from a resource file.

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

//

void CNssVasDb::OpenDatabaseL()

    {

    RUBY_DEBUG_BLOCK( "CNssVasDb::OpenDatabaseL" );

    if ( !iClientHasOpenedDatabase )

        {

        RFs fs;

        User::LeaveIfError( fs.Connect() );

        CleanupClosePushL ( fs ); // Stack: file session

        // Open the database

	    User::LeaveIfError( iDbSession.Connect() );

        User::LeaveIfError( iDatabase.Open( iDbSession, 

                            KVasDatabaseName, KVasDatabaseFormatString ) );

        User::LeaveIfError( fs.CharToDrive( KVasDatabaseDrive, iDrive ) );

        if ( iDatabase.IsDamaged() )

            {

            RUBY_DEBUG0( "CNssVasDb::OpenDatabaseL Recovering" );

            User::LeaveIfError( iDatabase.Recover() );

            }

        CleanupStack::PopAndDestroy( &fs ); 

	    iClientHasOpenedDatabase = ETrue;

        }

    }

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

// CNssVasDb::CloseDatabase

// Closes the database.

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

//

TInt CNssVasDb::CloseDatabase()

    {

    RUBY_DEBUG0( "CNssVasDb::CloseDatabase" ); 

    iDatabase.Close();

    iDbSession.Close();

    iClientHasOpenedDatabase = EFalse;

    return KErrNone;

    }

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

// CNssVasDb::GetModelBankIdLexiconIdL

// Returns the model bank ID and the lexicon ID.

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

//

TBool CNssVasDb::GetModelBankIdLexiconIdL( TUint32& aModelBankId, TUint32& aLexiconId )

    {

    TBool ret = EFalse;

    RDbView view;

    _LIT( KSQLGetModelBankLexicon, "select modelbankid,lexiconid from contexttable" );

    User::LeaveIfError( StartTransaction() );

    CreatePushRollbackItemLC();

    CleanupClosePushL( view );

    User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( 

                            KSQLGetModelBankLexicon, EDbCompareNormal ) ) );

    User::LeaveIfError( view.EvaluateAll() );

    // There is no ModelbankId or LexiconId 

    if ( view.IsEmptyL() )

        {

        User::Leave( KErrNotFound );

        }

    // There is a ModelBankId and a LexiconId 

    ret = ETrue;

    view.FirstL();

    view.GetL();

    // Get column set

    CDbColSet* columns = view.ColSetL();

    // Get column ordinals

    TDbColNo modelbankid_col = columns->ColNo( KModelBankIdCol );

    TDbColNo lexiconid_col = columns->ColNo( KLexiconIdCol );

    // Cleanup column set

    delete columns;

    aModelBankId = view.ColUint32( modelbankid_col );

    aLexiconId   = view.ColUint32( lexiconid_col );

    // Close view

    CleanupStack::PopAndDestroy( &view );

    // Release lock

    CleanupStack::Pop();  // Rollback cleanup item

    CommitTransaction( EFalse );

    return ret;

    }

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

// CNssVasDb::TagExistsL

// Checks if a context is empty.

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

//

TBool CNssVasDb::TagExistL( TInt aContextId )

    {

    RUBY_DEBUG_BLOCK( "CNssVasDb::TagExistL" );

    TBool   ret( EFalse );

    RDbView view;

    CleanupClosePushL(view);

    _LIT( KSQLGetTags, "select * from tagtable " );

    _LIT( KSQLWhereContextId, "where contextid=" );

    iSQLStatement = KSQLGetTags;

    iSQLStatement.Append( KSQLWhereContextId );

    iSQLStatement.AppendNumUC( aContextId );

    User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );

    User::LeaveIfError( view.EvaluateAll() );

    if ( view.IsEmptyL() )

        {

        ret = EFalse;

        }

    else

        {

        ret = ETrue;

        }

    // Close view

    CleanupStack::PopAndDestroy( &view );

    return ret;

    }

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

// CNssVasDb::TagCountL

// Returns the number of tags.

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

//

TInt CNssVasDb::TagCountL( TInt aContextId )

    {

    RUBY_DEBUG_BLOCK( "CNssVasDb::TagCountL" );

    RDbView view;

    TInt    numberOfTags = 0;

    CleanupClosePushL( view );

    _LIT( KSQLGetTags, "select * from tagtable " );

    _LIT( KSQLWhereContextId, "where contextid=" );

    iSQLStatement = KSQLGetTags;

    iSQLStatement.Append( KSQLWhereContextId );

    iSQLStatement.AppendNumUC( aContextId );

    User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );

    User::LeaveIfError( view.EvaluateAll() );

    numberOfTags = view.CountL();

    view.Close();

    CleanupStack::PopAndDestroy( &view );

    return numberOfTags;

    }

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

// CNssVasDb::CommitIfSuccess

// Commits or rolls back accoring to success parameter.

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

//

void CNssVasDb::CommitIfSuccess( RDbDatabase /*aDatabase*/, TInt aSuccess, TBool aCompactIfCommit )

    {

    if ( aSuccess >= 0 )

        {

        CommitTransaction( aCompactIfCommit );

        }

    else

        {

        // Otherwise, roll back the transaction and release the lock.

        RollbackTransaction();

        }

    }

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

// CNssVasDb::SaveContextL

// Saves a newly created context. The Context ID is assigned and returned

// using the reference parameter.

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

//

void CNssVasDb::SaveContextL( CNssContext& aContext, TInt& aContextId )

    {

    RUBY_DEBUG_BLOCK( "CNssVasDb::SaveContextL" );

    if ( !iClientHasOpenedDatabase )

        {

        RUBY_DEBUG0( "CNssVasDb error: database not opened." );

        User::Leave( KErrNotReady );

        }

    // Locks the database for the use of this process only

    TInt error = StartTransaction();

    if ( error != KErrNone )

        {

        RUBY_DEBUG0( "CNssVasDb error: could not lock database." );

        User::Leave( KErrGeneral );

        }

    TRAP( error, SaveContextL( &aContext, aContextId ) );

    REACT( error, RUBY_DEBUG0( "Context saving failed" ) );

    if ( error == KErrNone )

        {

        TRAP ( error, DoUpdateContextClientDataL( aContext ) );

        }

    CommitIfSuccess( iDatabase, error, ETrue );

    User::LeaveIfError( error );

    }

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

// CNssVasDb::UpdateContextL

// Updates the context to VAS DB.

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

//

void CNssVasDb::UpdateContextL( CNssContext& aContext )

    {

    RUBY_DEBUG_BLOCK( "CNssVasDb::UpdateContextL" );

    if ( !iClientHasOpenedDatabase )

        {

        RUBY_DEBUG0( "CNssVasDb error: database not opened." );

        User::Leave( KErrNotReady );

        }

    TInt error = StartTransaction();

    if ( error != KErrNone )

        {

        RUBY_DEBUG0( "CNssVasDb error: could not lock database." );

        User::Leave( KErrGeneral );

        }

    TRAP( error, DoUpdateContextL( aContext ) );

    REACT( error, RUBY_DEBUG0( "Context updating failed" ) );

    CommitIfSuccess( iDatabase, error, ETrue );

    User::LeaveIfError( error );

    }

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

// CNssVasDb::UpdateContextInsideTransactionL

// Updates the context to VAS DB.

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

//

void CNssVasDb::UpdateContextInsideTransactionL( CNssContext& aContext )

    {

    RUBY_DEBUG_BLOCK( "CNssVasDb::UpdateContextInsideTransactionL" );

    if ( !iClientHasOpenedDatabase )

        {

        RUBY_DEBUG0( "CNssVasDb error: database not opened." );

        User::Leave( KErrNotReady );

        }

    DoUpdateContextL( aContext );

    }

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

// CNssVasDb::UpdateContextClientDataL

// Updates the client data of the context.

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

//

void CNssVasDb::UpdateContextClientDataL( CNssContext& aContext )   

    {

    RUBY_DEBUG_BLOCK( "CNssVasDb::UpdateContextClientDataL" );

    if ( !iClientHasOpenedDatabase )

        {

        RUBY_DEBUG0( "CNssVasDb error: database not opened." );

        User::Leave( KErrNotReady );

        }

    TInt error = StartTransaction();

    if ( error != KErrNone )

        {

        RUBY_DEBUG0( "CNssVasDb error: could not lock database." );

        User::Leave( KErrGeneral );

        }

    TRAP( error, DoUpdateContextClientDataL( aContext ) );

    CommitIfSuccess( iDatabase, error, ETrue );

    User::LeaveIfError( error );

    }

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

// CNssVasDb::GetDefaultModelBankIdL

// Usually, all contexts use the same Model Bank. This function

// returns the first model bank ID it finds.

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

//

void CNssVasDb::GetDefaultModelBankIdL( TUint32& aId )

    {

    RUBY_DEBUG_BLOCK( "CNssVasDb::GetDefaultModelBankIdL" );

    _LIT( KSQLGetAll,"select modelbankid from contexttable");

    iSQLStatement = KSQLGetAll;

    if ( !iClientHasOpenedDatabase )

        {

        User::Leave( KErrDbNotSet );

        }

    StartTransaction();

    CreatePushRollbackItemLC();

    RDbView view;

    CleanupClosePushL(view);

    User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );

    User::LeaveIfError( view.EvaluateAll() );

    if ( view.IsEmptyL() )

        {

	    User::Leave( KErrNotFound );

        }

    // Get column set

    CDbColSet* columns = view.ColSetL();

    // Get model bank id column ordinal

	TDbColNo modelbankid_col= columns->ColNo( KModelBankIdCol );

	delete columns;

	view.FirstL();

    view.GetL(); // Retrieve the current row - actually reads the row from the database.

    aId = view.ColUint32( modelbankid_col );