/*

* Copyright (c) 2004-2007 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:  This class handles the storage and access of speaker independent

*               lexicons.  It is also responsible for allocating memory when

*               loading lexicons into the recognizer.

*

*/

// INCLUDE FILES

#include "silexicondb.h"

#include "rubydebug.h"

// CONSTANTS

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

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

// CSILexiconDB::CSILexiconDB

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

// might leave.

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

//

CSILexiconDB::CSILexiconDB( RDbNamedDatabase& aDatabase, 

                            RDbs& aDbSession,

                            TInt aDrive )

:	CSICommonDB(aDatabase, aDbSession, aDrive )

{

}

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

// CSILexiconDB::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSILexiconDB::ConstructL()

    {

    RUBY_DEBUG_BLOCK( "CSILexiconDB::ConstructL" );

    }

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

// CSILexiconDB::NewL

// Two-phased constructor.

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

//

CSILexiconDB* CSILexiconDB::NewL( RDbNamedDatabase& aDatabase, 

                                  RDbs& aDbSession,

                                  TInt aDrive )

    {

    RUBY_DEBUG_BLOCK( "CSILexiconDB::NewL" );

    CSILexiconDB* self 

        = new( ELeave ) CSILexiconDB( aDatabase, aDbSession, aDrive );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );	

    return self;

    }

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

// CSILexiconDB::~CSILexiconDB

// Destructor

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

//

CSILexiconDB::~CSILexiconDB()

    {

    // Delete all elements of the array before deleting the array

    //	iLexiconArray.ResetAndDestroy();

    //	iLexiconArray.Close();

    RUBY_DEBUG0( "CSILexiconDB::~CSILexiconDB" );

    }

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

// CSILexiconDB::CreateLexiconL

// Creates a new lexicon table in the database.

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

//

TSILexiconID CSILexiconDB::CreateLexiconL( TUid aClientUid )

    {

    RUBY_DEBUG_BLOCK( "CSILexiconDB::CreateLexiconL" );

    User::LeaveIfError( iDbSession.ReserveDriveSpace( iDrive, sizeof( CSILexicon ) ) );

    // Generate a new Lexicon ID

    TSILexiconID lexiconID = STATIC_CAST(TSILexiconID,CreateNewIDL(KLexiconIdTable, KLexiconIdColumn, aClientUid ));

    // Construct the table name using the new lexicon ID

    TBuf<40> KLexiconName( KSILexiconTable );

    KLexiconName.AppendNumUC( lexiconID );

    RUBY_DEBUG1( "CSILexiconDB::CreateLexiconL lexicon ID: %i", lexiconID );

    // Create a table definition

    CDbColSet* columns = CDbColSet::NewLC();

    // add the columns  

    // 1) Binary data, 2) binary data size

    columns->AddL( TDbCol( KBinaryLexiconColumn, EDbColLongBinary ) );

    columns->AddL( TDbCol( KBinaryLexiconColumnSize, EDbColUint32 ) );

    // Create a table

    TInt err =iDb.CreateTable( KLexiconName, *columns );

    if ( err != KErrNone )

        {

        // Failed to create the table.

        // Need to release the new Lexicon ID and leave.

        ReleaseIdL( KLexiconIdTable, KLexiconIdColumn, lexiconID );

        User::Leave( err );

        }

    // cleanup the column set

    CleanupStack::PopAndDestroy( columns );

    // Construct the table name using the provided grammar ID

    // Declare a literal string to hold the SQL statement

    // SELECT KBinaryLexiconColumn , KBinaryLexiconColumn FROM  KLexiconName

    _LIT(KSQLSelect1,"select  ");	

    _LIT(KSQLSelect2," from  ");		

    TBuf<120> KSQLStatement;		

    KSQLStatement.Append(KSQLSelect1  );	

    KSQLStatement.Append(KBinaryLexiconColumn );

    KSQLStatement.Append(KNext);

    KSQLStatement.Append(KBinaryLexiconColumnSize );	

    KSQLStatement.Append(KSQLSelect2  );

    KSQLStatement.Append(KLexiconName); 

    // create a view on the database

    RDbView view;

    User::LeaveIfError(view.Prepare(iDb,TDbQuery(KSQLStatement,EDbCompareNormal)));

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

    // Get the structure of rowset

    CDbColSet* colSet = view.ColSetL(); 

    view.InsertL();

    view.PutL();

    // close the view

    view.Close();

    delete colSet; 

    // add an empty lexicon

    CSILexicon *aLexicon=CSILexicon::NewL(lexiconID);	

    CleanupStack::PushL(aLexicon);

    UpdateLexiconL(aClientUid,aLexicon);

    CleanupStack::PopAndDestroy(aLexicon);	

    iDbSession.FreeReservedSpace( iDrive );

    return lexiconID;

    }

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

// CSILexiconDB::UpdateLexiconL

// Inserts the externalized SI Lexicon into the specified grammar table.

// Save the Lexicon into the database

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

//

void CSILexiconDB::UpdateLexiconL( TUid aClientUid, 

								   CSILexicon *aSILexicon )

    {

    //	__UHEAP_MARK;

    TSILexiconID aLexiconID=aSILexicon->LexiconID();

    VerifyOwnershipL(aClientUid, KLexiconIdTable, KLexiconIndex, aLexiconID);

    // Construct the table name using the provided grammar ID

    // Declare a literal string to hold the SQL statement

    // SELECT KBinaryLexiconColumn , KBinaryLexiconColumn FROM  KLexiconName

    TBuf<40> KLexiconName(KSILexiconTable);

    KLexiconName.AppendNumUC(aLexiconID);	

    _LIT(KSQLSelect1,"select  ");	

    _LIT(KSQLSelect2," from  ");		

    TBuf<120> KSQLStatement;		

    KSQLStatement.Append(KSQLSelect1  );	

    KSQLStatement.Append(KBinaryLexiconColumn );

    KSQLStatement.Append(KNext);

    KSQLStatement.Append(KBinaryLexiconColumnSize );	

    KSQLStatement.Append(KSQLSelect2  );

    KSQLStatement.Append(KLexiconName); 

    // create a view on the database

    RDbView view;

    User::LeaveIfError(view.Prepare(iDb,TDbQuery(KSQLStatement,EDbCompareNormal)));

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

    // Get the structure of rowset

    CDbColSet* colSet = view.ColSetL(); 

    view.FirstL(); 

    view.UpdateL();

    // Externalize grammar

    CBufFlat* dataCopyBuffer = CBufFlat::NewL( 100 ); // 100 = expand 100 bytes

    CleanupStack::PushL(dataCopyBuffer);              // when the buffer is full

    //TPtr8 Buft((TUint8*) abuf,3,3);

    //dataCopyBuffer->InsertL(0,Buft);

    RBufWriteStream stream;

    stream.Open(*dataCopyBuffer);

    CleanupClosePushL(stream);

    aSILexicon->ExternalizeL(stream);

    CleanupStack::PopAndDestroy( &stream );

    TPtr8 aWriteBuf(dataCopyBuffer->Ptr(0));

    TInt BufSize =aWriteBuf.Size();

    // add binary buffer by Using the stream  

    RDbColWriteStream out;

    TDbColNo col = colSet->ColNo(KBinaryLexiconColumn); // Ordinal position of long column	

    out.OpenLC(view, col);

    out.WriteL(aWriteBuf);	

    out.Close();	

    CleanupStack::PopAndDestroy(); // out

    // add  size of the buffer

    col = colSet->ColNo(KBinaryLexiconColumnSize); // Ordinal position of  size	

    view.SetColL( col,BufSize); 

    view.PutL();

    // close the view

    view.Close();

    delete colSet; 

    CleanupStack::PopAndDestroy( dataCopyBuffer ); 

    //	__UHEAP_MARKEND;

    }

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

// CSIGrammarDB::GetNewID

// Get a new uniq ID 

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

TInt CSILexiconDB::GetNewID( RArray<TSIRuleID>& aMyIds ) 

    {

    RArray<TSIRuleID> myIDs = aMyIds;

    TInt Count = myIDs.Count();

    TInt id = 0;

    if ( Count == 0 ) 

        {

        id = 1; // empty ,first id will be 1

        }

    else

        { 

        // Find a unique Rulevariant ID

        myIDs.SortUnsigned();

        id = myIDs[myIDs.Count() - 1] + 1; //by default , the last one 

        for ( TInt i = 0; i < myIDs.Count(); i++ ) 

            {

            TInt index = i + 1; 

            TInt s = myIDs[i];

            if ( s > index ) 

                {

                id = index;

                break;

                }

            }

        }

    return id;

    }

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

// CSILexiconDB::CreateIDTableL

// Creates a new lexicon ID table in the database.

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

//

void CSILexiconDB::CreateIDTableL()

    {

    // Invoke function in the base class CSICommonDB.

    CSICommonDB::CreateIDTableL(KLexiconIdTable, KLexiconIdColumn, KLexiconIndex);

    }

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

// CSILexiconDB::GetAllClientLexiconIDsL

// This function returns all Lexicon IDs owned by the specified client.

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

//

void CSILexiconDB::GetAllClientLexiconIDsL( TUid aClientUid,

										    RArray<TSILexiconID>& aLexiconIDs )

    {

    //	GetAllClientIDsL(KLexiconIdTable, KLexiconIdColumn, aClientUid, aLexiconIDs);

    RArray<TUint32> ix;

    ix.Reset();

    GetAllClientIDsL(KLexiconIdTable, KLexiconIdColumn, aClientUid, ix);

    for(TInt i=0;i<ix.Count();i++) 

        aLexiconIDs.Append(STATIC_CAST(TSILexiconID,ix[i]));

    ix.Close();

    }

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

// CSILexiconDB::GetAllLexiconIDsL

// This function returns all Lexicon IDs in the database.

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

//

void CSILexiconDB::GetAllLexiconIDsL( RArray<TSILexiconID>& aLexiconIDs )

    {

    // This is a hack to get the id aligned to 4-byte boundary,

    // for some reason this does not happen in winscw build if 

    // TSILexiconID is taken from stack.

    TSILexiconID* id = new (ELeave) TSILexiconID;

    CleanupStack::PushL( id );

    //	GetAllIDsL(KLexiconIdTable, KLexiconIdColumn, aLexiconIDs);

    RArray<TUint32> ix;

    ix.Reset();

    GetAllIDsL(KLexiconIdTable, KLexiconIdColumn, ix);

    for(TInt i=0;i<ix.Count();i++) 

        {

        *id = STATIC_CAST( TSILexiconID, ix[i] );

        aLexiconIDs.Append( *id );

        }

    ix.Close();

    CleanupStack::PopAndDestroy( id );

    }

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

// CSILexiconDB::GetAllPronunciationIDsL

// This function returns all Pronunciation IDs within the specified Lexicon.

// Lexicon have to be loaded 

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

//

void CSILexiconDB::GetAllPronunciationIDsL( TSILexiconID aLexiconID, RArray<TSIPronunciationID>& aPronunciationIDs )

    {

	CleanupClosePushL( aPronunciationIDs ); 

    // Construct the table name using the provided Lexicon ID

    TBuf<40> KLexiconName(KSILexiconTable);

    KLexiconName.AppendNumUC(aLexiconID);

    CSILexicon* newLexicon = LexiconL( aLexiconID) ;// Load the Lexicon from database	

    CleanupStack::PushL(newLexicon);

    TSIPronunciationID	aPronunciationID;

    for (TInt  i=0;i<newLexicon->Count();i++) {

        CSIPronunciation* aPronunciation=&(newLexicon->AtL(i));

        aPronunciationID=aPronunciation->PronunciationID();		

        User::LeaveIfError(aPronunciationIDs.Append(aPronunciationID));

        } 

    CleanupStack::PopAndDestroy(newLexicon); // newLexicon

    //	GetAllIDsL(KLexiconName, KPronunciationIDColumn, aPronunciationIDs);

    CleanupStack::Pop(); 

    }

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

// CSILexiconDB::RemoveLexiconL

// Deletes a Lexicon table from the database.

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

//

void CSILexiconDB::RemoveLexiconL( TUid aClientUid,

								   TSILexiconID aLexiconID )

    {

    VerifyOwnershipL(aClientUid, KLexiconIdTable, KLexiconIndex, aLexiconID);

    /* Some times removing of corrupted lexicon fails because of this:

    TInt diskSpace = ( PronunciationCountL(aLexiconID) * sizeof( CSIPronunciation ) )

        + sizeof( CSILexicon );

    User::LeaveIfError( iDbSession.ReserveDriveSpace( iDrive, diskSpace ) );

    */

    // Construct the table name using the provided Lexicon ID

    TBuf<40> KLexiconName(KSILexiconTable);

    KLexiconName.AppendNumUC(aLexiconID);

    TBuf<50> KSQLStatement;

    // Declare a literal string to hold the SQL statement

    // DROP TABLE KLexiconName

    _LIT(KSQLDelete1, "DROP TABLE ");

    KSQLStatement = KSQLDelete1;

    KSQLStatement.Append(KLexiconName);

    User::LeaveIfError(iDb.Execute(KSQLStatement));

    // Release the Lexicon ID

    ReleaseIdL(KLexiconIdTable, KLexiconIdColumn, aLexiconID);

    // Cancel free disk space request

    //iDbSession.FreeReservedSpace( iDrive );

    }

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

// CSILexiconDB::PronunciationCountL

// Returns the number of Pronunciations in the specified Lexicon.

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

TInt CSILexiconDB::PronunciationCountL( TSILexiconID aLexiconID )

    {

    CSILexicon* newLexicon = LexiconL( aLexiconID) ;	

    CleanupStack::PushL(newLexicon);

    TInt PronunciationCount=newLexicon->Count();	 

    CleanupStack::PopAndDestroy(newLexicon); 	

    return PronunciationCount;

    }

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

// CSILexiconDB::IsPronunciationValidL

// Checks if the specified pronunciation exists in the specified loaded	.

// 

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

//

TBool CSILexiconDB::IsPronunciationValidL( TSILexiconID aLexiconID,

                                           TSIPronunciationID aPronunciationID )

    {

    CSILexicon* newLexicon = LexiconL( aLexiconID) ;		 

    CleanupStack::PushL(newLexicon);

    if (newLexicon->Find(aPronunciationID)==KErrNotFound) {

        CleanupStack::PopAndDestroy(newLexicon); // newLexicon

        return EFalse; 

        }

    else {

        CleanupStack::PopAndDestroy(newLexicon); // newLexicon

        return ETrue;	

        }

    }

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

// CSILexiconDB::ResetAndDestroy

// Deallocates the temporary memory containing the Lexicon object created with

// AllPronunciationsL.

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

//

void CSILexiconDB::ResetAndDestroy()

    {

    //	iLexiconArray.ResetAndDestroy();

    }

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

// CSILexiconDB::RemovePronunciationL

// Deletes Pronunciation from the database.

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

//

void CSILexiconDB::RemovePronunciationL(  TUid aClientUid, 

                                        TSILexiconID aLexiconID,

                                        TSIPronunciationID aPronunciationID

                                        )

    {

    // Check the ownership first

    VerifyOwnershipL(aClientUid, KLexiconIdTable, KLexiconIndex, aLexiconID);

    CSILexicon* newLexicon = LexiconL( aLexiconID);		 

    CleanupStack::PushL(newLexicon);

    if (newLexicon->Find(aPronunciationID)==KErrNotFound)

        User::Leave(KErrNotFound);				 

    else  

        newLexicon->DeleteL(aPronunciationID);

    UpdateLexiconL(aClientUid  , newLexicon);

    CleanupStack::PopAndDestroy(newLexicon); // newLexicon

    }

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

// CSILexiconDB::AddPronunciationL

// Add Pronunciation to the database.

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

//

TSIPronunciationID CSILexiconDB::AddPronunciationL( TUid aClientUid, 

                                                   TSILexiconID aLexiconID,

                                                   TDesC8& aPronunciationPr,

                                                   TSIModelBankID aModelBankID)

    {

    // Check the ownership first

    VerifyOwnershipL( aClientUid, KLexiconIdTable, KLexiconIndex, aLexiconID );

    CSILexicon* aLexicon = LexiconL( aLexiconID );

    CleanupStack::PushL( aLexicon );

    // existing myPronunciationID

    RArray<TSIPronunciationID> myPronunciationID;

    myPronunciationID.Reset();

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

        {

        CSIPronunciation* aPronunciation = &( aLexicon->AtL( i ) );

        myPronunciationID.Append( aPronunciation->PronunciationID() );

        }

    // Find a uniq new id 

    TSIPronunciationID aPronunciationID = GetNewID( myPronunciationID );

    myPronunciationID.Close();

    // add the  phoneme sequence  to the Pronunciation

    CSIPronunciation* pronunciation = CSIPronunciation::NewL( aPronunciationID, aModelBankID );

    CleanupStack::PushL( pronunciation );	

    pronunciation->SetPhonemeSequenceL( aPronunciationPr );

    aLexicon->AddL( pronunciation );

    CleanupStack::Pop( pronunciation ); // aPronunciation

    UpdateLexiconL( aClientUid,aLexicon );

    CleanupStack::PopAndDestroy( aLexicon ); // aLexicon

    return aPronunciationID;

    }

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

// CSILexiconDB::LexiconL

// Loads all pronunciations within the specified lexicon into a lexicon object

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

//

CSILexicon* CSILexiconDB::LexiconL( TSILexiconID aLexiconID )

    {

    // Construct the table name using the provided grammar ID

    // Construct the table name using the provided grammar ID

    // Declare a literal string to hold the SQL statement

    // SELECT KBinaryLexiconColumn , KBinaryLexiconColumn FROM  KLexiconName

    TBuf<40> KLexiconName(KSILexiconTable);

    KLexiconName.AppendNumUC(aLexiconID);

    // Create newLexicon object	

    CSILexicon* lexicon = CSILexicon::NewLC( aLexiconID );	

    _LIT(KSQLSelect1,"select  ");	

    _LIT(KSQLSelect2," from  ");