/*

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

 *

 */

#include "casqlitestorage.h"

#include "caconsts.h"

#include "casqlcommands.h"

#include "casqlquery.h"

#include "casqlquerycreator.h"

#include "cainnerentry.h"

#include "cainnerquery.h"

#include "caarraycleanup.inl"

#include "calocalizationentry.h"

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

// CCASqLiteStorage::CCpStorageEngine()

//

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

//

CCaSqLiteStorage::CCaSqLiteStorage()

    {

    }

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

// CCASqLiteStorage::ConstructL()

//

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

//

void CCaSqLiteStorage::ConstructL()

    {

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

    User::LeaveIfError( CreatePrivateDirPath( iPrivatePathCDriveDb, KCDrive,

            KDbName ) );

    User::LeaveIfError( CreatePrivateDirPath( iPrivatePathZDriveDb, KZDrive,

            KDbName ) );

    User::LeaveIfError( CreatePrivateDirPath( iPrivatePathCDrive, KCDrive,

            KNullDesC ) );

    if( iSqlDb.Open( iPrivatePathCDriveDb, &KSqlDbConfig ) )

        {

        //we could not load data base from C-drive lets try Rom

        LoadDataBaseFromRomL();

        }

    }

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

// CCASqLiteStorage::NewL()

//

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

//

void CCaSqLiteStorage::LoadDataBaseFromRomL()

    {

    if( ( BaflUtils::FileExists( iRfs, iPrivatePathCDriveDb ) ) )

        {

        iSqlDb.Close();

        User::LeaveIfError( BaflUtils::DeleteFile( iRfs,

                iPrivatePathCDriveDb ) );

        }

    if( !( BaflUtils::FileExists( iRfs, iPrivatePathZDriveDb ) ) )

        {

                KErrNotFound );

        }

    else

        {

        if( !( BaflUtils::FolderExists( iRfs, iPrivatePathCDrive ) ) )

            {

            User::LeaveIfError( iRfs.CreatePrivatePath( EDriveC ) );

            }

        User::LeaveIfError( BaflUtils::CopyFile( iRfs,

                iPrivatePathZDriveDb, iPrivatePathCDrive ) );

        User::LeaveIfError( iRfs.SetAtt( iPrivatePathCDriveDb,

                KEntryAttNormal, KEntryAttReadOnly ) );

        User::LeaveIfError( iSqlDb.Open( iPrivatePathCDriveDb,

                &KSqlDbConfig ) );

        }

    }

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

// CCASqLiteStorage::NewL()

//

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

//

CCaSqLiteStorage* CCaSqLiteStorage::NewL()

    {

    CCaSqLiteStorage* self = CCaSqLiteStorage::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCASqLiteStorage::NewLC()

//

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

//

CCaSqLiteStorage* CCaSqLiteStorage::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCASqLiteStorage::~CCpStorageEngine()

//

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

//

CCaSqLiteStorage::~CCaSqLiteStorage()

    {

    iSqlDb.Close();

    iRfs.Close();

    }

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

// CCaSqLiteStorage::CreatePrivateDirPath()

//

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

//

TInt CCaSqLiteStorage::CreatePrivateDirPath( TFileName& aPrivatePath,

        const TDesC& aDrive, const TDesC& aDbName )

    {

    TInt error( KErrNone );

#ifdef CONTENT_ARSENAL_STORAGE_UT

    TFileName KPathWithoutDrive( KDoubleSlash );

#else

    TFileName KPathWithoutDrive;

    error = iRfs.PrivatePath( KPathWithoutDrive );

    if( error != KErrNone )

        {

        return error;

        }

#endif

    aPrivatePath.Copy( aDrive );

    aPrivatePath.Append( KPathWithoutDrive );

    aPrivatePath.Append( aDbName );

    return error;

    }

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

// CCASqLiteStorage::GetListL

//

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

//

void CCaSqLiteStorage::GetEntriesL( const CCaInnerQuery* aQuery,

        RPointerArray<CCaInnerEntry>& aResultContainer )

    {

    //    Fetch entries from

    CCaSqlQuery* sqlGetEntriesQuery = CCaSqlQuery::NewLC( iSqlDb );

    CaSqlQueryCreator::CreateGetEntriesQueryL( aQuery, sqlGetEntriesQuery );

    sqlGetEntriesQuery->PrepareL();

    sqlGetEntriesQuery->BindValuesForGetEntriesL( aQuery );

    sqlGetEntriesQuery->ExecuteL( aResultContainer, CCaSqlQuery::EEntry );

    CleanupStack::PopAndDestroy( sqlGetEntriesQuery );

    //    Populate the entries with their attributes

    if( aResultContainer.Count() > 0 )

        {

        CCaSqlQuery* sqlGetAttributesQuery = CCaSqlQuery::NewLC( iSqlDb );

        CaSqlQueryCreator::CreateGetAttributesQueryL(

                aResultContainer.Count(), sqlGetAttributesQuery );

        sqlGetAttributesQuery->PrepareL();

        sqlGetAttributesQuery->BindEntryIdsL( aResultContainer );

        sqlGetAttributesQuery->ExecuteL( aResultContainer,

                CCaSqlQuery::EAttribute );

        CleanupStack::PopAndDestroy( sqlGetAttributesQuery );

        }

    //  set entries if proper order if they were fetched by ids

    if( aQuery->GetIds().Count() > 0 )

        {

        SetEntriesInProperOrderL( aQuery->GetIds(), aResultContainer );

        }

    }

void CCaSqLiteStorage::LocalizeEntryL( CCaLocalizationEntry& aLocalization )

    {

    CCaSqlQuery* sqlLocalizeEntryQuery = CCaSqlQuery::NewLC( iSqlDb );

    CaSqlQueryCreator::CreateLocalizeEntryQueryL( sqlLocalizeEntryQuery );

    sqlLocalizeEntryQuery->PrepareL();

    sqlLocalizeEntryQuery->BindValuesForLocalizeL( aLocalization );

    sqlLocalizeEntryQuery->ExecuteL( );

    CleanupStack::PopAndDestroy( sqlLocalizeEntryQuery );

    }

void CCaSqLiteStorage::GetLocalizationsL(

        RPointerArray<CCaLocalizationEntry>& aResultContainer )

    {

    CCaSqlQuery* sqlGetLocalizationsQuery = CCaSqlQuery::NewLC( iSqlDb );

    CaSqlQueryCreator::CreateGetLocalizationsQueryL(

            sqlGetLocalizationsQuery );

    sqlGetLocalizationsQuery->PrepareL();

    sqlGetLocalizationsQuery->ExecuteLocalizationsL( aResultContainer );

    CleanupStack::PopAndDestroy( sqlGetLocalizationsQuery );

    }

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

// CCASqLiteStorage::GetEntriesIdsL

//

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

//

void CCaSqLiteStorage::GetEntriesIdsL( const CCaInnerQuery* aQuery,

        RArray<TInt>& aResultIdArray )

    {

    CCaSqlQuery* sqlGetEntriesIdsQuery = CCaSqlQuery::NewLC( iSqlDb );

    CaSqlQueryCreator::CreateGetEntriesQueryL( aQuery,

            sqlGetEntriesIdsQuery );

    sqlGetEntriesIdsQuery->PrepareL();

    sqlGetEntriesIdsQuery->BindValuesForGetEntriesL( aQuery );

    sqlGetEntriesIdsQuery->ExecuteL( aResultIdArray,

            CCaSqlQuery::EEntryTable );

    CleanupStack::PopAndDestroy( sqlGetEntriesIdsQuery );

    }

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

// CCASqLiteStorage::GetEntriesIdsL

//

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

//

void CCaSqLiteStorage::GetParentsIdsL( const RArray<TInt>& aEntryIdArray,

        RArray<TInt>& aParentIdArray )

    {

    CCaSqlQuery* sqlGetParentIdsQuery = CCaSqlQuery::NewLC( iSqlDb );

    CaSqlQueryCreator::CreateGetParentsIdsQueryL( aEntryIdArray,

            sqlGetParentIdsQuery, aParentIdArray );

    sqlGetParentIdsQuery->PrepareL();

    sqlGetParentIdsQuery->BindIdsL( aEntryIdArray, KSQLGEEntryId );

    if( aParentIdArray.Count() > 0 )

        {

        sqlGetParentIdsQuery->BindIdsL( aParentIdArray, KSQLGEIdGroup );

        }

    TInt parentCount = sqlGetParentIdsQuery->ExecuteL( aParentIdArray,

            CCaSqlQuery::EGroupTable );

    CleanupStack::PopAndDestroy( sqlGetParentIdsQuery );

    if( parentCount > 0 )

        {

        GetParentsIdsL( aParentIdArray, aParentIdArray );

        }

    }

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

// CCASqLiteStorage::AddL

//

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

//

void CCaSqLiteStorage::AddL( CCaInnerEntry* aEntry, TBool aUpdate)

    {

    RPointerArray<CCaSqlQuery> sqlQueries;

    CleanupResetAndDestroyPushL( sqlQueries );

    CaSqlQueryCreator::CreateAddQueryL( aEntry, sqlQueries, iSqlDb );

    ExecuteStatementL( KSqlStatementBegin );

    TRAPD( err, ExecuteAddL( aEntry, sqlQueries ) );

    if( err )

        {

        ExecuteStatementL( KSqlStatementRollback );

        User::Leave( err );

        }

    ExecuteStatementL( KSqlStatementCommit );

    CleanupStack::PopAndDestroy( &sqlQueries );

    if( aUpdate )

        {

        RemoveFromLocalizationL( aEntry->GetId() );

        }

    }

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

// CCASqLiteStorage::RemoveL

//

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

//

void CCaSqLiteStorage::RemoveL( const RArray<TInt>& aEntryIds )

    {

    ExecuteStatementL( KSqlStatementBegin );

    TRAPD( err, ExecuteRemoveL( aEntryIds ) );

    if( err )

        {

        ExecuteStatementL( KSqlStatementRollback );

        User::Leave( err );

        }

    ExecuteStatementL( KSqlStatementCommit );

    }

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

// CCASqLiteStorage::OrganizeL( const RArray<TInt>& aEntryIds,

//        TCaOperationParams aParams )

//

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

//

void CCaSqLiteStorage::OrganizeL( const RArray<TInt>& aEntryIds,

        TCaOperationParams aParams )

    {

    ExecuteStatementL( KSqlStatementBegin );

    TRAPD( err, ExecuteOrganizeL( aEntryIds, aParams ) );

    if( err )

        {

        ExecuteStatementL( KSqlStatementRollback );

        User::Leave( err );

        }

    ExecuteStatementL( KSqlStatementCommit );

    }

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

// CCASqLiteStorage::TouchL( const TInt aEntryId )

//

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

//

void CCaSqLiteStorage::TouchL( const TInt aEntryId )

    {

    ExecuteStatementL( KSqlStatementBegin );

    TRAPD( err, ExecuteTouchL( aEntryId ) );

    if( err )

        {

        ExecuteStatementL( KSqlStatementRollback );

        User::Leave( err );

        }

    ExecuteStatementL( KSqlStatementCommit );

    }

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

// CCASqLiteStorage::DbPropertyL

// ( const TDesC& aProperty, TDes& aPropertyValue )

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

//

void CCaSqLiteStorage::DbPropertyL( const TDesC& aProperty,

        TDes& aPropertyValue )

    {

    ExecuteStatementL( KSqlStatementBegin );

    TRAPD( err, ExecuteDbPropertyL( aProperty, aPropertyValue ) );

    if( err )

        {

        ExecuteStatementL( KSqlStatementRollback );

        User::Leave( err );

        }

    ExecuteStatementL( KSqlStatementCommit );

    }

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

// CCASqLiteStorage::SetDBPropertyL

// ( const TDesC& aProperty, const TDesC& aPropertyValue )

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

//

void CCaSqLiteStorage::SetDBPropertyL( const TDesC& aProperty,

        const TDesC& aPropertyValue )

    {

    ExecuteStatementL( KSqlStatementBegin );

    TRAPD( err, ExecuteSetDbPropertyL( aProperty, aPropertyValue ) );

    if( err )

        {

        ExecuteStatementL( KSqlStatementRollback );

        User::Leave( err );

        }

    ExecuteStatementL( KSqlStatementCommit );

    }

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

// CCaSqLiteStorage::RemoveFromLocalizationL( const TInt aEntryId )

//

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

//

void CCaSqLiteStorage::RemoveFromLocalizationL( const TInt aEntryId )

    {

    ExecuteStatementL( KSqlStatementBegin );

    TRAPD( err, ExecuteRemoveFromLocalizationL( aEntryId ) );

    if( err )

        {

        ExecuteStatementL( KSqlStatementRollback );

        User::Leave( err );

        }

    ExecuteStatementL( KSqlStatementCommit );

    }

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

// CCaSqLiteStorage::CustomSortL

// ( const RArray<TInt>& aEntryIds, const TInt aGroupId )

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

//

void CCaSqLiteStorage::CustomSortL( const RArray<TInt>& aEntryIds,

        const TInt aGroupId )

    {

    RPointerArray<CCaSqlQuery> sqlQueries;

    CleanupResetAndDestroyPushL( sqlQueries );

    CaSqlQueryCreator::CreateCustomSortQueryL(

            aEntryIds, sqlQueries, iSqlDb );

    ExecuteStatementL( KSqlStatementBegin );

    TRAPD( err, ExecuteCustomSortL( aEntryIds, aGroupId, sqlQueries ) );

    if( err )

        {

        ExecuteStatementL( KSqlStatementRollback );

        User::Leave( err );

        }

    ExecuteStatementL( KSqlStatementCommit );

    CleanupStack::PopAndDestroy( &sqlQueries );

    }

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

// CCaSqLiteStorage::ExecuteCustomSortL

// ( const RArray<TInt>& aEntryIds, const TInt aGroupId )

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

//

void CCaSqLiteStorage::ExecuteCustomSortL( const RArray<TInt>& aEntryIds,

        const TInt aGroupId , RPointerArray<CCaSqlQuery>& aSqlQuery )

    {

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

        {

        TInt newPosition = i + 1;

        TInt entryId = aEntryIds[i];

        aSqlQuery[i]->PrepareL();

        aSqlQuery[i]->BindValuesForCustomSortL( aGroupId, entryId, newPosition );

        aSqlQuery[i]->ExecuteL();

        aSqlQuery[i]->CloseStatement();

        }

    }

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

// CCaSqLiteStorage::ExecuteRemoveFromLocalizationL( const TInt aEntryId )

//

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

//

void CCaSqLiteStorage::ExecuteRemoveFromLocalizationL( const TInt aEntryId )

    {

    CCaSqlQuery* query = CCaSqlQuery::NewLC( iSqlDb );

    query->SetQueryL( KSQLDeleteLocalizationTextWhereEntryId );

    query->PrepareL();

    query->BindValuesForRemoveFromLocalizationL( aEntryId );

    query->ExecuteL();

    CleanupStack::PopAndDestroy( query );

    }

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

// CCASqLiteStorage::ExecuteStatementL( const TDesC& aStatement )

//

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

//

void CCaSqLiteStorage::ExecuteStatementL( const TDesC& aStatement )

    {

    CCaSqlQuery* query = CCaSqlQuery::NewLC( iSqlDb );

    query->SetQueryL( aStatement );

    query->PrepareL();

    query->ExecuteL();

    CleanupStack::PopAndDestroy( query );

    }

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

// CCASqLiteStorage::ExecuteAddL(CCaInnerEntry* aEntry,

//         RPointerArray<CCASqlQuery>& sqlQuery)

//

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

//

void CCaSqLiteStorage::ExecuteAddL( CCaInnerEntry* aEntry,

        RPointerArray<CCaSqlQuery>& aSqlQuery )

    {

    TBool isAttributeDeleted( EFalse );

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

        {

        if( aSqlQuery[i]->Type() == CCaSqlQuery::EIconTable )

            {

            //check if icon exists - just update

            CCaSqlQuery* query = CCaSqlQuery::NewLC( iSqlDb );

            query->SetQueryL( KSQLGetIconId );

            query->SetTableType( CCaSqlQuery::EIconTable );

            query->PrepareL();

            query->BindValuesForGetIconL( aEntry );

            CCaInnerEntry::TIconAttributes iconAttributes;

            TInt countIcons = query->ExecuteL( iconAttributes );

            CleanupStack::PopAndDestroy( query );

            aSqlQuery[i]->PrepareL();

            aSqlQuery[i]->BindValuesForAddL( aEntry );

            TInt tmpId( 0 );

            TRAPD( err, tmpId = aSqlQuery[i]->ExecuteL() );

            aSqlQuery[i]->CloseStatement();

            if( !countIcons && !aEntry->GetIconId() )

                { // new icon added

                aEntry->SetIconId( tmpId );

                }

            if( err == KSqlErrConstraint )

                {

                // ignore, this means that the icon cannot be removed

                // because some other entry has the same icon.

                }

            else if( err )