/*

 * 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 <driveinfo.h>

#include <hbtextresolversymbian.h>

#include "castorage.h"

#include "castorageproxy.h"

#include "castoragefactory.h"

#include "cainnerentry.h"

#include "cainnerquery.h"

#include "caarraycleanup.inl"

#include "calocalizationentry.h"

#include "casrvsession.h"

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

//

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

//

CCaStorageProxy::CCaStorageProxy()

    {

    }

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

//

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

//

void CCaStorageProxy::ConstructL()

    {

    iStorage = CaStorageFactory::NewDatabaseL();

    }

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

//

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

//

CCaStorageProxy* CCaStorageProxy::NewL()

    {

    CCaStorageProxy* self = CCaStorageProxy::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

CCaStorageProxy* CCaStorageProxy::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

//

CCaStorageProxy::~CCaStorageProxy()

    {

    delete iStorage;

    iHandlerNotifier.Close();

    }

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

//

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

//

EXPORT_C void CCaStorageProxy::GetEntriesL(const CCaInnerQuery* aQuery,

        RPointerArray<CCaInnerEntry>& aResultContainer )

    {

    iStorage->GetEntriesL( aQuery, aResultContainer );

    }

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

//

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

//

EXPORT_C void CCaStorageProxy::GetEntriesIdsL(const CCaInnerQuery* aQuery,

        RArray<TInt>& aResultIdArray)

    {

    iStorage->GetEntriesIdsL( aQuery, aResultIdArray );

    }

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

//

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

//

EXPORT_C void CCaStorageProxy::AddL( CCaInnerEntry* aEntry,

    TBool aUpdate,

    TItemAppearance aItemAppearanceChange )

    {

    TChangeType changeType = EAddChangeType;

    RArray<TInt> parentArray;

    CleanupClosePushL( parentArray );

    if( aEntry->GetId() > 0 )

        {

        changeType = EUpdateChangeType;

        RArray<TInt> id;

        CleanupClosePushL( id );

        id.AppendL( aEntry->GetId() );

        if (aItemAppearanceChange == EItemUninstallProgressChanged)

            {

            // no need to search for parent parents for uninstall 

            // progress change

            iStorage->GetParentsIdsL( id, parentArray, EFalse );

            }

        else

            {

            iStorage->GetParentsIdsL( id, parentArray );

            }

        CleanupStack::PopAndDestroy( &id );

        }

    if( aItemAppearanceChange==EItemDisappeared )

        {

        changeType = ERemoveChangeType;

        }

    else if( aItemAppearanceChange==EItemAppeared )

        {

        changeType = EAddChangeType;

        }

    // do not update entry in db with uninstall progress

    if (aItemAppearanceChange != EItemUninstallProgressChanged)

        {

        RPointerArray<CCaLocalizationEntry> localizations;

	    CleanupResetAndDestroyPushL( localizations );

        CCaLocalizationEntry* tempLocalization = NULL;

        if( aEntry->isLocalized( CCaInnerEntry::ENameLocalized ) )		

            {

            tempLocalization = LocalizeTextL( aEntry );

            if( tempLocalization )

                {

                localizations.Append( tempLocalization );

                tempLocalization = NULL;

                }

            }

        if( aEntry->isLocalized( CCaInnerEntry::EDescriptionLocalized ) )

            {

            tempLocalization = LocalizeDescriptionL( aEntry );

            if (tempLocalization)

                {

                localizations.Append(tempLocalization);

                tempLocalization = NULL;

                }

            }

        iStorage->AddL( aEntry, aUpdate );

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

            {

            localizations[j]->SetRowId( aEntry->GetId() );

            AddLocalizationL( *( localizations[j] ) );

            }

		if( localizations.Count() > 0 )

            {

            HbTextResolverSymbian::Init( _L(""), KLocalizationFilepathZ );

            }

		 CleanupStack::PopAndDestroy( &localizations );

        }

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

        {

        iHandlerNotifier[i]->EntryChanged( aEntry, changeType, parentArray );

        }

    CleanupStack::PopAndDestroy( &parentArray );

    }

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

//

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

//

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

    {

    CCaInnerQuery* query = CCaInnerQuery::NewLC();

    query->SetIdsL( aEntryIds );

    RPointerArray<CCaInnerEntry> resultContainer;

    CleanupResetAndDestroyPushL( resultContainer );

    RArray<TInt> parentArray;

    CleanupClosePushL( parentArray );

    if( aEntryIds.Count() > 0 )

        {

        iStorage->GetEntriesL( query, resultContainer );

        iStorage->GetParentsIdsL( aEntryIds, parentArray );

        }

    iStorage->RemoveL( aEntryIds );

    for( TInt i( 0 ); i < resultContainer.Count(); i++ )

        {

        for( TInt j( 0 ); j < iHandlerNotifier.Count(); j++ )

            {

            iHandlerNotifier[j]->EntryChanged( resultContainer[i],

                    ERemoveChangeType, parentArray );

            }

        }

    CleanupStack::PopAndDestroy( &parentArray );

    CleanupStack::PopAndDestroy( &resultContainer );

    CleanupStack::PopAndDestroy( query );

    }

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

//

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

//

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

        TCaOperationParams aParams )

    {

    iStorage->OrganizeL( aEntryIds, aParams );

    RArray<TInt> parentArray;

    CleanupClosePushL( parentArray );

    parentArray.AppendL( aParams.iGroupId );

    iStorage->GetParentsIdsL( parentArray, parentArray );

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

        {

        iHandlerNotifier[i]->GroupContentChanged( parentArray );

        }

    CleanupStack::PopAndDestroy( &parentArray );

    }

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

//

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

//

EXPORT_C void CCaStorageProxy::TouchL( CCaInnerEntry* aEntry )

    {

    CCaInnerQuery* touchQuery = CCaInnerQuery::NewLC();

    TInt entryId = aEntry->GetId();

    if ( entryId == 0 && aEntry->GetUid() != 0)

        {

        CCaInnerQuery* idQuery = CCaInnerQuery::NewLC();

        idQuery->SetUid( static_cast<TUint>( aEntry->GetUid()) );

        RArray<TInt> idArray;

        CleanupClosePushL( idArray );

        iStorage->GetEntriesIdsL( idQuery, idArray );

        if (idArray.Count() == 1 )

            {

            entryId = idArray[0];

            aEntry->SetId( entryId );

            }

        CleanupStack::PopAndDestroy( &idArray );

        CleanupStack::PopAndDestroy( idQuery );

        }

    RArray<TInt> id;

    CleanupClosePushL( id );

    id.AppendL( entryId );

    touchQuery->SetIdsL( id );

    RPointerArray<CCaInnerEntry> resultArray;

    CleanupResetAndDestroyPushL( resultArray );

    iStorage->GetEntriesL( touchQuery, resultArray );

    iStorage->TouchL( entryId, aEntry->GetFlags() & ERemovable );

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

        {

        iHandlerNotifier[i]->EntryTouched( entryId );

        }

    if( resultArray.Count() > 0 )

        {

        if( !( resultArray[0]->GetFlags() & EUsed ) )

            {

            RArray<TInt> parentArray;

            CleanupClosePushL( parentArray );

            iStorage->GetParentsIdsL( id, parentArray );

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

                {

                resultArray[0]->SetFlags( 

                        resultArray[0]->GetFlags() | EUsed );

                iHandlerNotifier[i]->EntryChanged( resultArray[0],

                        EUpdateChangeType,

                        parentArray );

                }

            CleanupStack::PopAndDestroy( &parentArray );

            }

        }

    CleanupStack::PopAndDestroy( &resultArray );

    CleanupStack::PopAndDestroy( &id );

    CleanupStack::PopAndDestroy( touchQuery );

    }

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

//

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

//

EXPORT_C void CCaStorageProxy::GetLocalizationsL(

        RPointerArray<CCaLocalizationEntry>& aResultArray )

    {

    iStorage->GetLocalizationsL( aResultArray );

    }

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

//

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

//

EXPORT_C void CCaStorageProxy::LocalizeEntryL(

        CCaLocalizationEntry& aLocalization )

    {

    iStorage->LocalizeEntryL( aLocalization );

    }

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

//

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

//

EXPORT_C void CCaStorageProxy::AddLocalizationL(

		const CCaLocalizationEntry& aLocalization)

	{

	iStorage->AddLocalizationL(aLocalization);

	}

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

//

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

//

EXPORT_C void CCaStorageProxy::DbPropertyL( const TDesC& aProperty,

        TDes& aPropertyValue )

    {

    iStorage->DbPropertyL( aProperty, aPropertyValue );

    }

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

//

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

//

EXPORT_C void CCaStorageProxy::SetDBPropertyL( const TDesC& aProperty,

        const TDesC& aPropertyValue )

    {

    iStorage->SetDBPropertyL( aProperty, aPropertyValue );

    }

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

//

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

//

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

        const TInt aGroupId )

    {

    iStorage->CustomSortL( aEntryIds, aGroupId );

    RArray<TInt> parentArray;

    CleanupClosePushL( parentArray );

    parentArray.AppendL( aGroupId );

    iStorage->GetParentsIdsL( parentArray, parentArray );

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

        {

        iHandlerNotifier[i]->GroupContentChanged( parentArray );

        }

    CleanupStack::PopAndDestroy( &parentArray );

    }

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

//

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

//

#ifdef COVERAGE_MEASUREMENT

#pragma CTC SKIP

#endif //COVERAGE_MEASUREMENT (calls another method)

EXPORT_C void CCaStorageProxy::SaveDatabaseL()

    {

    iStorage->SaveDatabaseL();

    }

#ifdef COVERAGE_MEASUREMENT

#pragma CTC ENDSKIP

#endif //COVERAGE_MEASUREMENT

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

//

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

//

#ifdef COVERAGE_MEASUREMENT

#pragma CTC SKIP

#endif //COVERAGE_MEASUREMENT (calls another method)

EXPORT_C void CCaStorageProxy::RestoreDatabaseL()

    {

    iStorage->RestoreDatabaseL();

    }

#ifdef COVERAGE_MEASUREMENT

#pragma CTC ENDSKIP

#endif //COVERAGE_MEASUREMENT

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

//

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

//

#ifdef COVERAGE_MEASUREMENT

#pragma CTC SKIP

#endif //COVERAGE_MEASUREMENT (calls another method)

EXPORT_C void CCaStorageProxy::LoadDataBaseFromRomL()

    {

    iStorage->LoadDataBaseFromRomL();

    }

#ifdef COVERAGE_MEASUREMENT

#pragma CTC ENDSKIP

#endif //COVERAGE_MEASUREMENT

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

//

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

//

void CCaStorageProxy::AddSessionL( MCaSessionNorifier* aHandlerNotifier )

    {

    __ASSERT_ALWAYS(

            iHandlerNotifier.Find( aHandlerNotifier ) == KErrNotFound,

            User::Invariant() );

    iHandlerNotifier.AppendL( aHandlerNotifier );

    }

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

//

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

//

void CCaStorageProxy::RemoveSession( MCaSessionNorifier* aHandlerNotifier )

    {

    TInt i = iHandlerNotifier.Find( aHandlerNotifier );

    if( i != KErrNotFound )

        {

        iHandlerNotifier.Remove( i );

        }

    }

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

//

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

//

CCaLocalizationEntry* CCaStorageProxy::LocalizeTextL( CCaInnerEntry* aEntry )

    {

	CCaLocalizationEntry* result = NULL;

	TInt textLength = aEntry->GetText().Length();

	if (textLength > 0)

		{

		TChar delimiter = '/'; // cannot add it as global

		RBuf title;

		CleanupClosePushL( title );

		title.CreateL( aEntry->GetText() );

		TInt pos = title.LocateReverse( delimiter );

		if ( pos > 0 && pos + 1 < textLength )   // 1 is for delimiters

			{

			TPtrC16 logString = title.Mid( pos + 1 ); 

			TInt qmFileNameLength = textLength - charsToFilename - 1 - logString.Length();

			TPtrC16 qmFile = title.Mid( charsToFilename, qmFileNameLength );

			if ( InitializeTranslatorL( qmFile ) )

				{

			    result = CCaLocalizationEntry::NewLC();			

				HBufC* translatedString = HbTextResolverSymbian::LoadLC( logString );

				if ( translatedString->Compare( logString ) )

					{

					result->SetStringIdL( logString );

					aEntry->SetTextL( *translatedString );

					if( translatedString )

						{

					    CleanupStack::PopAndDestroy( translatedString );

						}

					result->SetTableNameL( KLocalizationCaEntry );

					result->SetAttributeNameL( KLocalizationEnText );

					result->SetQmFilenameL( qmFile );

					result->SetRowId( aEntry->GetId() ? 0 : aEntry->GetId() ); // must be added when present

					CleanupStack::Pop( result );

					}

				else 

					{

					CleanupStack::PopAndDestroy(translatedString);

					CleanupStack::PopAndDestroy(result);

					result = NULL;

					}

				}

			}

		CleanupStack::PopAndDestroy( &title );

		}

	return result;

	}

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

//

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

//

CCaLocalizationEntry* CCaStorageProxy::LocalizeDescriptionL( CCaInnerEntry* aEntry )

    {

	CCaLocalizationEntry* result = NULL;

	TInt dscLength = aEntry->GetDescription().Length();

	if ( dscLength )

		{

		TChar delimiter = '/'; // cannot add it as global

		RBuf description;

		CleanupClosePushL( description );

		description.CreateL( aEntry->GetDescription() );

		TInt pos = description.LocateReverse( delimiter );

		if ( pos > 0 && pos + 1 < dscLength )   // 1 is for delimiters

			{

			TPtrC16 logString = description.Mid(pos + 1);

			TInt qmFileNameLength = dscLength - charsToFilename - 1 - logString.Length();

			TPtrC16 qmFile = description.Mid(charsToFilename, qmFileNameLength);

			if ( InitializeTranslatorL( qmFile ) )

				{

			    result = CCaLocalizationEntry::NewLC();

				HBufC* translatedString = HbTextResolverSymbian::LoadLC( logString );

				if ( translatedString->Compare( logString ) )

					{

					result->SetStringIdL( logString );

					aEntry->SetDescriptionL( *translatedString );

					CleanupStack::PopAndDestroy( translatedString );

					result->SetTableNameL( KLocalizationCaEntry );