/*

* 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:   ?Description

*

*/

#include "ncddatabasestorageimpl.h"

#include <bamdesca.h>

#include <bautils.h>

#include "ncdstoragedataitem.h"

#include "ncdstoragepanics.pan"

#include "ncdpanics.h"

#include "catalogsutils.h"

#include "ncddatabaseitems.h"

//#include "catalogsdebug.h"

// disable logging for this file

#undef DLTRACEIN

#define DLTRACEIN( x )

#undef DLTRACEOUT

#define DLTRACEOUT( x )

#undef DLTRACE

#define DLTRACE( x )

#undef DLINFO

#define DLINFO( x )

#undef DLERROR

#define DLERROR( x )

#undef DASSERT

#define DASSERT( x )

// SQL statement for creation of the database table

_LIT( KNcdSqlCreateStorageTable, "\

 CREATE TABLE storage (\

 row_id COUNTER,\

 item_id LONG VARCHAR,\

 item_type INTEGER,\

 item_data LONG VARBINARY)" );

enum TNcdDatabaseTableColumns

    {

    ENcdDatabaseTableColumnsId = 1,

    ENcdDatabaseTableColumnsItemId,

    ENcdDatabaseTableColumnsItemType,

    ENcdDatabaseTableColumnsItemData

    };

// SQL statement for deleting a row from the database table

_LIT( KNcdSqlRemoveItem, "DELETE FROM storage WHERE row_id = %d" );

// These are used for removing everything else but some certain ids from a db

_LIT( KNcdSqlRemoveItemsStart, "DELETE FROM storage WHERE " );           

_LIT( KNcdSqlRemoveItemType, "NOT ( item_type = %d" );

_LIT( KNcdSqlRemoveItemAnd, " AND " );

_LIT( KNcdSqlRemoveItemStart, " AND ( item_id = '" );        

_LIT( KNcdSqlRemoveItemStartNoType, " NOT (( item_id = '" );        

_LIT( KNcdSqlRemoveItemOrId, "' OR item_id = '" );

_LIT( KNcdSqlRemoveItemEnd, "'))" );

_LIT( KNcdSqlRemoveItemEmptyEnd, ")" );

// Select one item from the database by item id and type

_LIT( KNcdSqlSelectOneRowByIdAndType,  "SELECT * FROM storage WHERE item_id = '%S' AND item_type = %d" );

// Select one item from the database by item key

_LIT( KNcdSqlSelectOneRowByKey,  "SELECT * FROM storage WHERE row_id = %d" );

// Select all items from the database

_LIT( KNcdSqlSelectAll,  "SELECT * FROM storage" );

// File extension for database file

_LIT( KNcdDatabaseFileExtension, "*.db" );

// Amount of disk space in bytes that database is

// allowed to waste before it is compressed

const TInt KNcdMaxDatabaseWastedSpace = 100000;

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

// 

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

//

CNcdDatabaseStorage::~CNcdDatabaseStorage()

    {

    DLTRACEIN(( "this-ptr: %X", this ));

    DoClose();

    if ( iDatabaseFileName ) 

        {

        DLTRACE(( _L("Database filename: %S"), iDatabaseFileName ));

        }

    delete iDatabaseFileName;

    DLTRACEOUT((""));

    }

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

// 

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

//

CNcdDatabaseStorage* CNcdDatabaseStorage::NewL(

    RFs& aFs,

    const TDesC& aUid,

    const TDesC& aStorageFolder,

    const TDesC& aName )

    {

    DLTRACEIN(( _L("Uid: %S, folder: %S, name: %S"), &aUid, &aStorageFolder,

        &aName ));

    HBufC* uid = aUid.AllocLC();

    HBufC* storageFolder = aStorageFolder.AllocLC();

    HBufC* name = aName.AllocLC();

    DLTRACE(("Creating CNcdDatabaseStorage"));

    CNcdDatabaseStorage* storage = new (ELeave) CNcdDatabaseStorage( 

        aFs, uid, storageFolder, name );

    DLINFO(("CNcdDatabaseStorage created"));

    CleanupStack::Pop( 3 ); // uid, storageFolder, name

    DLTRACE(("storage-ptr: %X", storage));

    DASSERT( storage );

    CleanupStack::PushL( storage );

    DLTRACE(("Calling constructL"));

    storage->ConstructL();

    CleanupStack::Pop( storage );    

    return storage;

    }

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

// 

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

//

CNcdDatabaseStorage::CNcdDatabaseStorage( 

    RFs& aFs,

    HBufC* aUid, HBufC* aStorageFolder, HBufC* aName ) :

    CNcdStorageBase( aUid, aStorageFolder, aName ),

    iFs( aFs ),

    iDatabaseFileName( NULL ),

    iUpdated( EFalse ),

    iWastedSpace( 0 ),

    iNewWastedSpace( 0 )

    {    

    }

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

// 

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

//

void CNcdDatabaseStorage::ConstructL()

    {    

    DLTRACEIN(( _L("StorageFolder: %S, Name: %S"), iStorageFolder, iName ));

    TParse fileName;

    fileName.Set( *iStorageFolder, iName, &KNcdDatabaseFileExtension );

    iDatabaseFileName = fileName.FullName().AllocL();

    DLTRACEOUT(( _L("Fullname: %S"), iDatabaseFileName ));

    }

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

// Compact

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

//    

void CNcdDatabaseStorage::Compact()

    {

    DLTRACEIN((""))

    iDb.Compact();

    }

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

// 

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

//    

RDbDatabase::TSize CNcdDatabaseStorage::Size() const

    {

    if( iOpen )

        {

        return iDb.Size();

        }

    else

        {

        User::Panic( KNcdStoragePanic, ENcdStoragePanicStorageNotOpen );

        }

    // For compiler

    return RDbDatabase::TSize();

    }

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

// 

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

//

TInt CNcdDatabaseStorage::DoCommit()

    {

    DLTRACEIN(( "this-ptr: %X", this ));

    if( iDb.InTransaction() )

        {

        TRAPD( err, CloseTransactionL( ETrue ) );

        return err;

        }

    else

        {

        DLTRACE(("Nothing to commit"));

        return KErrNone;

        }

    }

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

// 

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

//

void CNcdDatabaseStorage::DoOpenL()

    {

    DLTRACEIN(("this-ptr: %X", this));

    //User::LeaveIfError( iFs.Connect() );

    DLTRACE((_L("Opening database: %S"), iDatabaseFileName ));

    // Try to open the database

    TInt err = iDb.Open( iFs, *iDatabaseFileName );

    if( err == KErrNone )

        {       

        if ( iDb.IsDamaged() ) 

            {

            DLTRACE(( "DB is damaged, try to recover" ));            

            TInt recoverErr = iDb.Recover();

            if ( recoverErr != KErrNone ) 

                {

                DLTRACE(("DB couldn't be recovered, recreate it"));

                RecreateDatabaseL();

                }

            }

        iDb.Compact();        

        }

    else if( err == KErrNotFound ) // If not found, create it

        {

        DLINFO(( "Data base file not found. New one is created." ));

        RecreateDatabaseL();

        }

    else if ( err == KErrCorrupt || err == KErrEof ) 

        {

        DLINFO(("Database corrupted! Create new one"));

        RecreateDatabaseL();

        }

    else

        {

        DLERROR(( "Failed with err: %i", err ));

        User::Leave( err );

        }

    DLTRACEOUT((""));

    }

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

// 

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

//

void CNcdDatabaseStorage::DoClose()

    {

    DLTRACEIN(("this-ptr: %X", this));

    if( iOpen && iDb.InTransaction() )

        {

        DLTRACE(("Rollback"));

        iDb.Rollback();

        }

    DLINFO(("Close db"));

    iDb.Close();      

    DLINFO(("db closed"));

    iWastedSpace = 0;

    iNewWastedSpace = 0;

    iUpdated = EFalse;

    DLTRACEOUT((""));

    }

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

// 

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

//

CNcdStorageItem* CNcdDatabaseStorage::CreateStorageItemLC( const TDesC& aUid, 

    TInt aType )

    {

    DLTRACEIN(( "this-ptr: %X",this ));

    CNcdDatabaseStorageItem* item = CNcdDatabaseStorageItem::NewLC( this, aUid, 

        aType );    

    // Begin transaction if not already began

    BeginTransactionL();

    RDbView dbView;

    ReadItemDataLC( dbView, aUid, aType, RDbRowSet::EUpdatable );

    if( !dbView.FirstL() ) // Item doesn't exist in database. Create it.

        {

        // Add new row

        dbView.InsertL();

        // Write uid to newly created row

        dbView.SetColL( ENcdDatabaseTableColumnsItemId, aUid );

        // Write type to newly created row

        dbView.SetColL( ENcdDatabaseTableColumnsItemType, aType );

        // Confirms row addition

        // This doesn't commit row to the database if transaction is started

        // In this case the row is not permanently inserted to database until the

        // last open item is closed and transaction commited.

        dbView.PutL();

        }

    dbView.GetL(); // Get item data

     // Read key column from db table and store it to the item

    item->SetDbKey( dbView.ColUint32( ENcdDatabaseTableColumnsId ) );

    CleanupStack::PopAndDestroy( &dbView );    

    return item;

    }

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

// 

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

//

void CNcdDatabaseStorage::GetAllItemsFromStorageL( 

    RPointerArray<CNcdStorageItemIdentifier>& aItems )

    {

    DLTRACEIN(( "this-ptr: %X",this ));

    CleanupResetAndDestroyPushL( aItems );

    RDbView dbView;    

    // Read all data from database

    User::LeaveIfError( dbView.Prepare( iDb, TDbQuery( KNcdSqlSelectAll ), 

        RDbRowSet::EReadOnly ) );

    CleanupClosePushL( dbView );

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

    dbView.BeginningL();

    RDbColReadStream readStream;

    TInt count = dbView.CountL( RDbRowSet::EQuick );

    if ( count && count != KDbUndefinedCount ) 

        {

        DLTRACE(("Reserving %d slots for the items array", count ));

        aItems.ReserveL( count );

        }

    // Loop through the whole record set and store

    // item ids and types to array

    while( dbView.NextL() )

        {

        dbView.GetL();

        TInt type = dbView.ColInt( ENcdDatabaseTableColumnsItemType );

        readStream.OpenLC( dbView, ENcdDatabaseTableColumnsItemId );

        HBufC8* id = GetAllDataLC( readStream );

        CNcdStorageItemIdentifier* itemIdentifier = 

            CNcdStorageItemIdentifier::NewLC(

                *id,

                type );

        aItems.AppendL( itemIdentifier );

        CleanupStack::Pop( itemIdentifier );

        CleanupStack::PopAndDestroy( 2, &readStream ); // id, readStream

        }

    CleanupStack::PopAndDestroy( &dbView );

    CleanupStack::Pop( &aItems );

    }

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

// 

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

//

HBufC8* CNcdDatabaseStorage::DoGetDataL( CNcdStorageItem* aItem )

    {

    DLTRACEIN(( "this-ptr: %X", this ));

    CNcdDatabaseStorageItem* item = (CNcdDatabaseStorageItem*) aItem;

    HBufC8* dataBuffer = NULL;

    RDbView dbView;

    ReadItemDataLC( dbView, item->DbKey() );

    if( dbView.FirstL() )

        {

        dbView.GetL();

        RDbColReadStream readStream;

        readStream.OpenLC( dbView, ENcdDatabaseTableColumnsItemData );

        dataBuffer = GetAllDataL( readStream );

        CleanupStack::PopAndDestroy( &readStream );

        }

    else

        {

        DLINFO(("Didn't find the item. Leaving with KErrNotFound"));

        // Item not found.

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( &dbView );

    DLTRACEOUT((""));

    return dataBuffer;

    }

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

// 

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

//

void CNcdDatabaseStorage::DoRemoveItemsL( 

    const RArray<RNcdDatabaseItems>& aDoNotRemoveItems )

    {

    DLTRACEIN((""));

    NCD_ASSERT_ALWAYS( aDoNotRemoveItems.Count(), ENcdPanicInvalidArgument );

/*

    This is the intended output:

    DELETE FROM storage WHERE 

        NOT ( item_type = 5 AND ( item_id = 'id1' OR item_id = 'id2' ))

        AND NOT ( item_type = 6 AND ( item_id = 'id3' OR item_id = 'id2' )) 

        AND NOT ( item_id = 'id4' )

*/    

    TInt sqlStatementSize = KNcdSqlRemoveItemsStart().Length();

    TInt count = aDoNotRemoveItems.Count();

    while ( count-- ) 

        {

        sqlStatementSize += 

            CalculateSqlRemovalLength( aDoNotRemoveItems[ count ] ) +

            KNcdSqlRemoveItemAnd().Length();

        }

    DLTRACE(("Max length of sql statement: %d", sqlStatementSize ));

    // SQL statement

    HBufC* sqlBuf = HBufC::NewLC( sqlStatementSize );

    TPtr sql = sqlBuf->Des();

    // DELETE FROM storage WHERE

    sql.Append( KNcdSqlRemoveItemsStart );    

    count = aDoNotRemoveItems.Count();

    for ( TInt i = 0; i < count; ++i )

        {

        DASSERT( aDoNotRemoveItems[i].iType != KErrNotFound ||

                 aDoNotRemoveItems[i].Uids().MdcaCount() );

        if ( aDoNotRemoveItems[i].iType != KErrNotFound ) 

            {            

            // NOT ( item_type = x

            sql.AppendFormat( KNcdSqlRemoveItemType, aDoNotRemoveItems[i].iType );

            }

        if ( aDoNotRemoveItems[i].Uids().MdcaCount() ) 

            {

            const MDesCArray& uids = aDoNotRemoveItems[i].Uids();

            TInt uidCount = uids.MdcaCount();

            // append first item

            // AND ( item_id = '

            if ( aDoNotRemoveItems[i].iType != KErrNotFound ) 

                {                

                sql.Append( KNcdSqlRemoveItemStart );

                }

            else 

                {

                // NOT (( item_id = '

                sql.Append( KNcdSqlRemoveItemStartNoType );

                }

            sql.Append( uids.MdcaPoint( 0 ) );

            DLTRACE(( _L("Added: %S"), &uids.MdcaPoint( 0 ) ));

            for ( TInt u = 1; u < uidCount; ++u ) 

                {

                // ' OR item_id = '

                sql.Append( KNcdSqlRemoveItemOrId ); 

                sql.Append( uids.MdcaPoint( u ) );

                DLTRACE(( _L("Added: %S"), &uids.MdcaPoint( u ) ));