/*

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

#include "cainternaltypes.h"

#include "cadef.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();

        }

    else

        {

        TBuf<KCaMaxAttrNameLen> versionValue;

        DbPropertyL(KCaDbPropVersion, versionValue);

        ASSERT(versionValue.Length()>0);

        if( versionValue.CompareC( KCaDbVersion ) )

            {

            // database loaded from C: is obsolete, load from Z:

            iSqlDb.Close();

            LoadDataBaseFromRomL();

            }

        }

    }

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

// CCASqLiteStorage::NewL()

//

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

//

void CCaSqLiteStorage::LoadDataBaseFromRomL()

    {

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

        {

        iSqlDb.Close();

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

                iPrivatePathCDriveDb ) );

        }

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

        {

        User::Panic( _L("fatal error - castorage.db not exists in ROM"),

                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::CreateLocalizationTableQueryL( sqlLocalizeEntryQuery,

            KSQLLocalizeTextEntry );

        }

    else if ( aLocalization.GetAttributeName().Compare(

            KColumnEnDescription ) == 0 )

        {

        CaSqlQueryCreator::CreateLocalizationTableQueryL( sqlLocalizeEntryQuery,

            KSQLLocalizeDescriptionEntry );

        }

    sqlLocalizeEntryQuery->PrepareL();

    sqlLocalizeEntryQuery->BindValuesForLocalizeL( aLocalization );

    sqlLocalizeEntryQuery->ExecuteL( );

    CleanupStack::PopAndDestroy( sqlLocalizeEntryQuery );

    }

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

//

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

//

void CCaSqLiteStorage::AddLocalizationL(

        const CCaLocalizationEntry& aLocalization)

    {

    if (LocalizationEntryPresentL(aLocalization))

        {

        ExecuteLocalizationStatementL(aLocalization, KSQLUpdateLocalization);

        }

    else

        {

        ExecuteLocalizationStatementL(aLocalization, KSQLAddLocalization);

        }

    }

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

//

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

//

TBool CCaSqLiteStorage::LocalizationEntryPresentL(

        const CCaLocalizationEntry& aLocalization)

    {

    TBool result(EFalse);

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

    CaSqlQueryCreator::CreateLocalizationTableQueryL(sqlQuery,

            KSQLGetLocalization);

    sqlQuery->PrepareL();

    sqlQuery->BindValuesForGetLocalizationEntryL( aLocalization );

    result = sqlQuery->ExecuteEntryPresentL( );

    CleanupStack::PopAndDestroy( sqlQuery );

    return result;

    }

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

//

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

//

void CCaSqLiteStorage::ExecuteLocalizationStatementL(

        const CCaLocalizationEntry& aLocalization, const TDesC& aStatement)

    {

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

    CaSqlQueryCreator::CreateLocalizationTableQueryL(sqlQuery,aStatement );

    sqlQuery->PrepareL();

    sqlQuery->BindValuesForLocalizationEntryL( aLocalization );

    sqlQuery->ExecuteL( );

    CleanupStack::PopAndDestroy( sqlQuery );

    }

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

//

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

//

void CCaSqLiteStorage::GetLocalizationsL(

        RPointerArray<CCaLocalizationEntry>& aResultContainer )

    {

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

    CaSqlQueryCreator::CreateLocalizationTableQueryL(

            sqlGetLocalizationsQuery, KSQLGetLocalizations );

    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, TBool aCheckParentsParent )

    {

    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( aCheckParentsParent && 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 )

//

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

//

    {

    ExecuteStatementL( KSqlStatementBegin );

    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 )