/*

* Copyright (c) 2008 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:      SQLite Connection class

*

*/

#include "cmdmsqliteconnection.h"

#include "cmdmsqlclausedef.h"

#include "cmfillrule.h"

#include "cmfillrulecontainer.h"

#include "cmmediaserverfull.h"

#include "cmstorerule.h"

#include "cmfilllistitem.h"

#include "cmstorelistitem.h"

#include "cmdriveinfo.h"

#include "cmsearchresponsehash.h"

#include "msdebug.h"

// Constants

_LIT8( KCmDbPragmaCacheSize, "PRAGMA cache_size=4096;PRAGMA page_size=4096;");

const TUint8 KAmountOfIDs = 10;

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

// CCmDmSQLiteConnection::NewL

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

//

CCmDmSQLiteConnection* CCmDmSQLiteConnection::NewL()

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::NewL()"));

    CCmDmSQLiteConnection* self = CCmDmSQLiteConnection::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCmDmSQLiteConnection::NewLC

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

//    

CCmDmSQLiteConnection* CCmDmSQLiteConnection::NewLC()

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::NewLC()"));

    CCmDmSQLiteConnection* self = new ( ELeave ) CCmDmSQLiteConnection();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;  

    }    

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

// CCmDmSQLiteConnection::~CCmDmSQLiteConnection

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

//

CCmDmSQLiteConnection::~CCmDmSQLiteConnection()

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::~CCmDmSQLiteConnection()"));

    TRAP_IGNORE( BackUpIdL( ERuleGroupID, iRuleGroupID ) );

    TRAP_IGNORE( BackUpIdL( ERuleID, iRuleID ) );

    TRAP_IGNORE( BackUpIdL( ERuleParamID, iRuleParamID ) );

    TRAP_IGNORE( BackUpIdL( EMediaServerID, iMediaServerID ) );

    TRAP_IGNORE( BackUpIdL( EStoredID, iStoredID ) );

    TRAP_IGNORE( BackUpIdL( EFilledID, iFilledID ) );

    TRAP_IGNORE( BackUpIdL( EStoreRuleID, iStoreRuleID ) );

    TRAP_IGNORE( BackUpIdL( EStoreRuleParamID, iStoreRuleParamID ) );

    TRAP_IGNORE( BackUpIdL( EFillFileListId, iFillFileId ) );

    TRAP_IGNORE( BackUpIdL( EStoreFileListId, iStoreFileId ) );

    CloseDb();

    }

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

// CCmDmSQLiteConnection::OpenDb

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

//

TInt CCmDmSQLiteConnection::OpenDb( const TDesC& aDb )

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::OpenDb()"));

    TInt err( iDatabase.Open( aDb, NULL ) );

    if ( err != KErrNone )

        {

        TRACE(Print(_L("[DATABASE MANAGER]\t CCmDmSQLiteConnection::OpenDb()\

         error %d"), err));

        }

    else 

        {

        err = iDatabase.Exec( KCmDbPragmaCacheSize );        

        }

    return err;

    }

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

// CCmDmSQLiteConnection::CloseDb

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

//

void CCmDmSQLiteConnection::CloseDb()

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::CloseDb()"));

    iDatabase.Close();         

    }

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

// CCmDmSQLiteConnection::InitIDs

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

//

void CCmDmSQLiteConnection::InitIDs()

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::InitIDs()"));

    TInt err = iStatement.Prepare( iDatabase, KAddIDs );

    if( err )

        {

        TRACE(Print(_L("[DATABASE MANAGER]\t \

            CCmDmSQLiteConnection::SetIDs() FAILED ")));

        }

    else

        {

        for( TInt j=1; j <= KAmountOfIDs ; j++ )

            {    

            SetID( static_cast<TTypeOfID>(j) );

            }

        iStatement.Close();        

        }          

    }

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

// CCmDmSQLiteConnection::SetID

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

//    

void CCmDmSQLiteConnection::SetID( TTypeOfID aType )

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::SetID()"));

    // Init all ids to one    

    iStatement.BindInt64( 0, 1 );

    iStatement.BindInt( 1, aType );

    iStatement.Exec();

    iStatement.Reset();        

    }

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

// CCmDmSQLiteConnection::BackUpIdL

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

//

void CCmDmSQLiteConnection::BackUpIdL( TTypeOfID aType, TUint64 aID )

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::BackUpIdL()"));

    iStatement.PrepareL( iDatabase, KUpdateID );

    iStatement.BindInt64( 0, aID );

    iStatement.BindInt( 1, aType );

    iStatement.Exec();

    iStatement.Reset();

    iStatement.Close();

    }

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

// CCmDmSQLiteConnection::LoadIDs

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

//

void CCmDmSQLiteConnection::LoadIDs()

    {    

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::LoadIDs()"));

    TRAP_IGNORE( LoadIDL( iRuleGroupID, ERuleGroupID ) );

    TRAP_IGNORE( LoadIDL( iRuleID, ERuleID ) );

    TRAP_IGNORE( LoadIDL( iRuleParamID, ERuleParamID ) );

    TRAP_IGNORE( LoadIDL( iMediaServerID, EMediaServerID ) );

    TRAP_IGNORE( LoadIDL( iStoredID, EStoredID ) );

    TRAP_IGNORE( LoadIDL( iFilledID, EFilledID ) );

    TRAP_IGNORE( LoadIDL( iStoreRuleID, EStoreRuleID ) );

    TRAP_IGNORE( LoadIDL( iStoreRuleParamID, EStoreRuleParamID ) );

    TRAP_IGNORE( LoadIDL( iFillFileId, EFillFileListId) );

    TRAP_IGNORE( LoadIDL( iStoreFileId, EStoreFileListId) );       

    }

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

// CCmDmSQLiteConnection::LoadIDL

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

//

void CCmDmSQLiteConnection::LoadIDL( TUint64& aId, TTypeOfID aType )

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::LoadIDL()"));

    TInt err = iStatement.Prepare( iDatabase, KSelectID );

    if( err )

            {

            TRACE(Print(_L("[DATABASE MANAGER]\t \

                CCmDmSQLiteConnection::LoadIDL() FAILED ")));

            User::Leave( err );

            }

    else

        {

        iStatement.BindInt( 0, aType );

        // get id

        err = iStatement.Next();

        if (  err == KSqlAtRow )  

            {

            aId = iStatement.ColumnInt64( 0 );

            }

        iStatement.Reset();

        iStatement.Close();                    

        }            

    }

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

// CCmDmSQLiteConnection::CreateDbFile

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

//

TInt CCmDmSQLiteConnection::CreateDbFile( const TDesC& aDb )

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::CreateDbFile()"));

    TInt err( iDatabase.Create( aDb ) );

    return err;

    }

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

// CCmDmSQLiteConnection::Validate

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

//

TBool CCmDmSQLiteConnection::Validate()

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::Validate()"));

    TInt ret( KErrNone );

    TInt err = iStatement.Prepare( iDatabase, 

        KValidateTableExistence );

    // Loop only one row in results

    if( err )

        {

        ret = KErrGeneral;

        }

    else

        {

        err = iStatement.Next();    

        if ( err != KSqlAtRow )  

            {

            ret = KErrGeneral;       

            }

        iStatement.Reset();

        iStatement.Close();          

        }                     

    TBool retval = EFalse;

    if ( ret == KErrNone ) 

        {

        retval = ETrue;

        }

    return retval;

    }

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

// CCmDmSQLiteConnection::ExecuteL

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

//

void CCmDmSQLiteConnection::ExecuteL( const TDesC8& aCommand )

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::ExecuteL()"));

    TInt err( iDatabase.Exec( aCommand ) );

    if ( KErrNone > err  )

        {

        User::Leave( err );    

        }    

    }

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

// CCmDmSQLiteConnection::SetFillFiles

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

//    

TInt CCmDmSQLiteConnection::SetFillFiles( 

    RPointerArray<CCmFillListItem>& aItems )

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::SetFillFiles()"));

    iDatabase.Exec( KCmDbBeginTransaction );

    TInt err(KErrNone);

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

        {

        err = iStatement.Prepare( iDatabase, KAddFillFile );

        if( err )

            {

            TRACE(Print(_L("[DATABASE MANAGER]\t Prepare err = %d"), err ));

            }

        else

            {

            iStatement.BindInt64( 0, aItems[i]->DbId() );  

            iStatement.BindText( 1, aItems[i]->PrimaryText() );

            iStatement.BindText( 2, 

                aItems[i]->SecondaryText() );

            iStatement.BindText( 3, aItems[i]->Path() );

            iStatement.BindBinary( 4, aItems[i]->Uri() );

            iStatement.BindBinary( 5, aItems[i]->ItemId() );

            iStatement.BindText( 6, aItems[i]->UpnpClass() );

            iStatement.BindInt( 7, aItems[i]->MediaType() );

            iStatement.BindInt( 8, aItems[i]->Priority() );

            iStatement.BindInt( 9, aItems[i]->Size() );

            iStatement.BindInt( 10, aItems[i]->Status() );

            iStatement.BindInt64( 11, aItems[i]->Date().Int64() );

            iStatement.BindInt( 12, aItems[i]->ListId() );

            iStatement.BindInt( 13, aItems[i]->DevId() );

            iStatement.BindInt64( 14, aItems[i]->RefId() );

            iStatement.BindInt( 15, aItems[i]->Selected() );

            iStatement.BindInt64( 16, aItems[i]->DriveId() );

            iStatement.BindInt( 17, aItems[i]->DriveNumber() );

            iStatement.Exec();

            iStatement.Reset();  

            iStatement.Close();        

            }            

        }

    iDatabase.Exec( KCmDbSqlCommit );

    return err;

    }

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

// CCmDmSQLiteConnection::SetStoreFilesL

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

//    

TInt CCmDmSQLiteConnection::SetStoreFilesL( 

    RPointerArray<CCmStoreListItem>& aItems )

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::SetStoreFilesL()"));

    iDatabase.Exec( KCmDbBeginTransaction );

    TInt err(KErrNone);

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

        {

        err = iStatement.Prepare( iDatabase, KAddStoreFile );

        if( err )

            {

            err = KErrGeneral;

            }

        else

            {   

            iStatement.BindInt64( 0, iStoreFileId );

            iStatement.BindText( 1, aItems[i]->PrimaryText() );

            iStatement.BindText( 2, 

                aItems[i]->SecondaryText() );

            iStatement.BindText( 3, aItems[i]->Path() );

            iStatement.BindInt( 4, aItems[i]->Size() );

            iStatement.BindInt64( 5, aItems[i]->Date().Int64() );

            iStatement.BindInt( 6, aItems[i]->ListId() );

            iStatement.Exec();

            iStatement.Reset();

            iStatement.Close();            

            }    

        /** INSERT Server */

        RArray<TInt> serverIds( aItems[i]->DevIds() );

        RArray<TCmListItemStatus> statusValues( aItems[i]->StatusValues() );

        for( TInt j = 0; j < serverIds.Count(); j++ )

            {

            err = iStatement.Prepare( iDatabase, KAddStoreFileServer );

            if( err )

                {

                err = KErrGeneral;

                }

            else

                {

                iStatement.BindInt64( 0, iStoreFileId );

                iStatement.BindInt( 1, serverIds[j] );

                iStatement.BindInt( 2, statusValues[j] );

                iStatement.Exec();

                iStatement.Reset();

                iStatement.Close();            

                }            

            }

        iStoreFileId++;                        

        }

    iDatabase.Exec( KCmDbSqlCommit );

    BackUpIdL( EStoreFileListId, iStoreFileId );

    return err;

    }

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

// CCmDmSQLiteConnection::AddStoreFile

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

//

TInt CCmDmSQLiteConnection::AddStoreFile( CCmStoreListItem& aItem )

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::AddStoreFile()"));

    TInt err(KErrNone);

    err = iStatement.Prepare( iDatabase, KAddStoreFile );

    if( err )

        {

        err = KErrGeneral;

        }

    else

        {

        iStatement.BindInt64( 0, iStoreFileId );

        iStatement.BindText( 1, aItem.PrimaryText() );

        iStatement.BindText( 2, aItem.SecondaryText() );

        iStatement.BindText( 3, aItem.Path() );

        iStatement.BindInt( 4, aItem.Size() );

        iStatement.BindInt64( 5, aItem.Date().Int64() );

        iStatement.BindInt64( 6, aItem.ListId() );            

        iStatement.Exec();

        iStatement.Reset();

        iStatement.Close();

        /** INSERT Server */

        RArray<TInt>serverIds( aItem.DevIds() );

        RArray<TCmListItemStatus>statusValues( aItem.StatusValues() );        

        for( TInt j = 0; j < serverIds.Count() ; j++ )

            {

            err = iStatement.Prepare( iDatabase, KAddStoreFileServer );

            if( err )

                {

                err = KErrGeneral;

                }

            else

                {

                iStatement.BindInt64( 0, iStoreFileId );

                iStatement.BindInt( 1, serverIds[j] );

                iStatement.BindInt( 2, statusValues[j] );

                iStatement.Exec();

                iStatement.Reset();

                iStatement.Close();            

                }            

            }                

        }

    iStoreFileId++;            

    return err;

    }

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

// CCmDmSQLiteConnection::AddStoredL

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

//

TInt CCmDmSQLiteConnection::AddStoredL( 

    const TDesC& aFileName, 

    const TDesC8& aUDN, 

    TTime aTimeStamp )

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::AddStoredL()"));

    /* FIRST QYERY MediaServerID from the MediaServer table

    using UDN */

    TInt err = iStatement.Prepare( iDatabase, KSelectMediaServerIDByUDN ) ;

    TUint64 mediaServerID(0);    

    if( err )

        {

        TRACE(Print(_L("[DATABASE MANAGER]\t KSelectMediaServerIDByUDN \

            FAILED ")));

        err = KErrGeneral;

        }

    else

        {

        iStatement.BindBinary( 0, aUDN );

        // Loop only one row in results

        err = iStatement.Next();

        if ( err == KSqlAtRow )  

            {

            // Get cell contents    

            mediaServerID = iStatement.ColumnInt64( 0 );

            iStatement.Reset();            

            iStatement.Close();  // Destruct statement  

            err = KErrNone;          

            }        

        }

    err = iStatement.Prepare( iDatabase, KAddStored );

    if( err )

        {

        TRACE(Print(_L("[DATABASE MANAGER]\t KAddStored FAILED ")));

        err = KErrGeneral;

        }

    else

        {

        iStatement.BindInt64( 0, iStoredID );

        iStatement.BindText( 1, aFileName );          

        iStatement.BindInt64( 2, mediaServerID );    

        iStatement.BindInt64( 3, aTimeStamp.Int64() );

        iStatement.Exec();

        iStatement.Reset();

        iStatement.Close();

        err = KErrNone;   

        }

    iStoredID++;

    BackUpIdL( EStoredID, iStoredID );                

    return err;    

    }

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

// CCmDmSQLiteConnection::AddFillRuleL

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

//    

TInt CCmDmSQLiteConnection::AddFillRuleL( CCmFillRule* aFillRule )

    {

    LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::AddFillRuleL()"));

    iDatabase.Exec( KCmDbBeginTransaction );

    TInt err = iStatement.Prepare( iDatabase, KAddFillGroup );

    if ( err == KErrNone )

        {

        if( aFillRule->ListId() )

            {

            iRuleGroupID = aFillRule->ListId();

            }

        iStatement.BindInt64( 0, iRuleGroupID );        

        iStatement.BindBinary( 1, aFillRule->Name() );

        iStatement.BindInt( 2, aFillRule->Method() );

        iStatement.BindInt( 3, aFillRule->LimitType() );

        iStatement.BindInt( 4, aFillRule->Amount() );

        iStatement.BindInt( 5, aFillRule->Selected() );

        iStatement.BindInt( 6, aFillRule->Priority() );

        iStatement.BindInt( 7, aFillRule->TemplateId() );