/*

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

#include <s32mem.h>

#include <escapeutils.h>

#include "cpserverdatamanager.h"

#include "ccontentmap.h"

#include "cpublisherregistrymap.h"

#include "cpstorage.h"

#include "cpdebug.h"

#include "cpstoragefactory.h"

#include "cpglobals.h"

#include "cpserversession.h"

#include "cpnotificationhandler.h"

using namespace LIW;

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

// C++ destructor

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

//

CCPDataManager::~CCPDataManager()

    {

    delete iActionDataCache;

    iNotificationsArray.Close( );

    delete iStorage;

    }

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

// 

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

//

CCPDataManager* CCPDataManager::NewL( TBool aBool )

    {

    CCPDataManager* self = CCPDataManager::NewLC( aBool );

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

//

CCPDataManager* CCPDataManager::NewLC( TBool aBool )

    {

    CCPDataManager* self = new( ELeave ) CCPDataManager;

    CleanupStack::PushL( self );

    self->ConstructL( aBool );

    return self;

    }

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

// C++ constructor.

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

//

CCPDataManager::CCPDataManager()

    {

    }

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

// Standard 2nd phase constructor.

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

//

void CCPDataManager::ConstructL( TBool aBool )

    {

    CP_DEBUG( _L8("CCPDataManager::ConstructL()") );

    if ( !aBool )

        {

        iStorage = StorageFactory::NewDatabaseL( );

        }

    iActionDataCache = CCPActionDataCache::NewL();

    }

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

// 

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

//

TUint CCPDataManager::AddDataL( CCPLiwMap& aMap )

    {

    CP_DEBUG( _L8("CCPDataManager::AddDataL()") );

    __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );

    CCPLiwMap* getlistmap = CreateMapForGetlistLC( aMap );

    iActionDataCache->HandleCacheRemoveL( &aMap );

    TBool activateMap = aMap.GetActivateInfo();

    TBool activateDB ( EFalse );

    TBool activateSupport =aMap.ActivateActionSupport( );

   	if( activateSupport )

	    {

	    activateDB = GetActivateInfoL( getlistmap );

	    }   

    TInt id = iStorage->AddL( &aMap );

    if( activateSupport )

        {

        if ( activateMap && !activateDB )

            {

            // append action trigger for activate

            aMap.InsertL( KActionTrigger, TLiwVariant( KActivateTrigger ) ); 

            }

        if ( !activateMap && activateDB )

            {

            // append action trigger for deactivate

            aMap.InsertL( KActionTrigger, TLiwVariant( KDeactivateTrigger ) ); 

            }

        //remove flag from map ( needed because map will be used in getlist 

        //operation )                

        aMap.Remove( KFlag );  

        }

    CleanupStack::PopAndDestroy( getlistmap );

    return id;

    }

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

//

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

//

void CCPDataManager::AddNonPersistentDataL( const CCPLiwMap* aMap )

    {

    CLiwDefaultList* notificationList = CLiwDefaultList::NewLC( );

    BuildChangeInfoForAddL( aMap, notificationList );

    HandleChangeL( notificationList );

    CleanupStack::PopAndDestroy( notificationList );

    }

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

//

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

//

void CCPDataManager::GetListL( const CCPLiwMap& aMap,

    CLiwGenericParamList& aOutParamList )

    {

    CP_DEBUG( _L8("CCPDataManager::GetListL()") );

    __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );

    iStorage->GetListL( &aMap, aOutParamList );

    }

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

// 

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

//

TInt CCPDataManager::GetActionsL( const CCPLiwMap& aMap, TBool aEnableCache,

    CLiwGenericParamList& aOutParamList, CLiwDefaultList* aNotificationList )

    {

    CP_DEBUG( _L8("CCPDataManager::GetActionL()") );

    __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );

    CLiwGenericParamList* paramList = CLiwGenericParamList::NewLC( );

    TInt result( KErrNone );

    CLiwDefaultList* actionTriggers = aMap.GetActionTriggersLC();

    if ( actionTriggers )

        {

        TBool cacheable = iActionDataCache->IsCacheableL( &aMap );

        if (aEnableCache && cacheable && iActionDataCache->ExistL( &aMap ))

            {

            iActionDataCache->GetL( &aMap, paramList );

            }

        else 

            {

            TRAP( result, iStorage->GetListL( &aMap, *paramList ) );

            if ( aEnableCache && cacheable && result == KErrNone )

                {

                iActionDataCache->AppendL(paramList);

                }

            }

        const TLiwGenericParam* param;

    	TInt pos( 0);

        param = paramList->FindFirst( pos, KListMap );

        //at least one param should be valid to preceed

        if ( !param || pos == KErrNotFound )

        	{

        	BuildDefaultChangeInfoL(&aMap, actionTriggers, aNotificationList);

        	}

        //iteration through paramList items

    	while ( param && pos != KErrNotFound )

    		{

    		BuildChangeInfoL( &aMap, actionTriggers, param, 

    		        aNotificationList );

    		FillActionParamListL( aOutParamList, param, actionTriggers );

    		param = paramList->FindNext( pos, KListMap );

    		}

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( actionTriggers );

    CleanupStack::PopAndDestroy( paramList );

    return result;

    }

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

// 

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

//

void CCPDataManager::FillActionParamListL( 

		CLiwGenericParamList& aOutParamList, 

		const TLiwGenericParam* aParam,

		const CLiwDefaultList* aActionTriggers)

	{

    CP_DEBUG( _L8("CCPDataManager::FillActionParamListL()") );

    __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );

	RBuf8 actionBinaries;

	actionBinaries.CleanupClosePushL();

	ExtractActionL(  aParam, actionBinaries );

	RDesReadStream str(actionBinaries);

	CleanupClosePushL( str );

	CLiwDefaultMap* actionMap = CLiwDefaultMap::NewLC( str );

    TLiwVariant trigger;

    trigger.PushL();

    TInt count = aActionTriggers->Count();

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

	    {

	    trigger.Reset();

	    aActionTriggers->AtL( i,trigger );

	    ExtractTriggerL( aOutParamList, actionMap, trigger.AsData());

	    }

    CleanupStack::PopAndDestroy(&trigger);

	CleanupStack::PopAndDestroy( actionMap );

	CleanupStack::PopAndDestroy( &str );

	CleanupStack::PopAndDestroy( &actionBinaries );

	}

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

// 

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

//

void CCPDataManager::GetActivePublishersL( CLiwGenericParamList* aResultList )

    {

    CCPLiwMap *map = CPublisherRegistryMap::NewLC();

    map->InsertL( KFlag, TLiwVariant( TUint( 0 | EActivate ) ) );

    iStorage->GetListL( map, *aResultList );

    CleanupStack::PopAndDestroy(map);

    }

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

// 

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

//

void CCPDataManager::ExtractTriggerL( CLiwGenericParamList& aOutParamList,

    const CLiwDefaultMap* aMap, const TDesC8& aTrigger )

    {

    CP_DEBUG( _L8("CCPDataManager::GetActionL()") );

    CLiwDefaultMap* targetMap = CLiwDefaultMap::NewLC( );

    TLiwVariant variant;

    variant.PushL( );

    if ( aMap->FindL( aTrigger, variant ) )

        {

        targetMap->InsertL( KActionMap, variant );

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    TLiwGenericParam result( KListMap, TLiwVariant( targetMap ));

    aOutParamList.AppendL( result );

    CleanupStack::PopAndDestroy( &variant );

    CleanupStack::PopAndDestroy( targetMap );

    }

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

// 

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

//

void CCPDataManager::RemoveDataL( const CCPLiwMap& aMap )

    {

    CP_DEBUG( _L8("CCPDataManager::RemoveData()") );

    __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );

    iActionDataCache->HandleCacheRemoveL( &aMap );

    iStorage->RemoveL( &aMap );

    }

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

//

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

//

void CCPDataManager::AddObserverL(

    CCPNotificationHandler* aNotificationHandler )

    {

    CP_DEBUG( _L8("CCPDataManager::AddObserverL()") );

    __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );

    iNotificationsArray.AppendL( aNotificationHandler );

    if ( iNotificationsArray.Count( ) == 1 )

        {

        iStorage->SetCallback( this );

        }

    }

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

//

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

//

void CCPDataManager::RemoveObserver(

    CCPNotificationHandler* aNotificationHandler )

    {

    CP_DEBUG( _L8("CCPDataManager::RemoveObserver()") );

    TInt index = iNotificationsArray.Find( aNotificationHandler );

        {

        }

    }

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

//

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

//

void CCPDataManager::HandleChangeL( CLiwDefaultList* aListOfMaps )

    {

    CP_DEBUG( _L8("CCPDataManager::HandleChangeL()") );

    //for every session

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

        {

        TRAPD(error, SendNotificationL(aListOfMaps, i));

        if ( error )

            {

            iNotificationsArray[i]->ErrorComplete( error );

            }

        }

    }

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

//

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

//

void CCPDataManager::CloseDatabase()

    {

    CP_DEBUG( _L8("CCPDataManager::CloseDatabase()") );

    delete iStorage;

    iStorage = NULL;

    }

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

//

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

//

void CCPDataManager::OpenDatabaseL()

    {

    CP_DEBUG( _L8("CCPDataManager::OpenDatabaseL()") );

    if ( !iStorage )

        {

        iStorage = StorageFactory::NewDatabaseL( );

        // Restore storage observers

        if ( iNotificationsArray.Count() > 0 )

            {

            iStorage->SetCallback( this );

            }

        }

    }

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

//

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

//

void CCPDataManager::SendNotificationL( CLiwDefaultList* aListOfMaps,

    TInt aIndex )

    {

    CP_DEBUG( _L8("CCPDataManager::SendNotificationL()") );

    iNotificationsArray[aIndex]->SendNotificationL( aListOfMaps );

    }

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

//

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

//

void CCPDataManager::ExtractActionL( const TLiwGenericParam* aParam, RBuf8& aAction )

    {

    CP_DEBUG( _L8("CCPDataManager::ExtractActionL()") );

    if ( aParam->Value().TypeId() != EVariantTypeMap )

		{

		User::Leave( KErrArgument );

		}

	TLiwVariant variant; variant.PushL( );

	TPtrC8 tempBuf( KNullDesC8 );

	if ( aParam->Value().AsMap()->FindL( KActionMap, variant ) 

			&& variant.Get( tempBuf ) )

		{

		aAction.CreateL( tempBuf );

		}

	else

		{

		User::Leave( KErrArgument );

		}

	CleanupStack::PopAndDestroy( &variant );

    }

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

// 

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

//    

CCPLiwMap* CCPDataManager::CreateMapForGetlistLC( const CCPLiwMap& aMap )

    {

    CCPLiwMap *resultmap = CPublisherRegistryMap::NewLC();

    RBuf publisher;

    publisher.CleanupClosePushL();

    RBuf content_type;

    content_type.CleanupClosePushL();

    RBuf content_id;

    content_id.CleanupClosePushL();

    aMap.GetPropertyL( KContentType, content_type );

    aMap.GetPropertyL( KContentId, content_id ); 

    aMap.GetPropertyL( KPublisherId, publisher );

    resultmap->InsertL( KPublisherId, TLiwVariant( publisher ));

    resultmap->InsertL( KContentId, TLiwVariant( content_id ));

    resultmap->InsertL( KContentType, TLiwVariant( content_type ));

    CleanupStack::PopAndDestroy( &content_id );

    CleanupStack::PopAndDestroy( &content_type );

    CleanupStack::PopAndDestroy( &publisher );

    return resultmap;

    }

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

// 

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

//    

TBool CCPDataManager::GetActivateInfoL( const CCPLiwMap* aMap )

    {

    TBool result( EFalse );

    CLiwGenericParamList* outList = CLiwGenericParamList::NewLC();

	TRAPD(err,GetListL(*aMap,*outList));

	if (err == KErrNone)

	    {

	    TInt pos( 0 );

        outList->FindFirst( pos, KListMap );

        if( pos != KErrNotFound )

       	    {

   	    	TLiwVariant variant = (*outList)[pos].Value();

   	        if ( variant.TypeId() == EVariantTypeMap )

   	        	{

   	            if (variant.AsMap()->FindL( KFlag, variant ))

       	            {

   	    		    TUint flag;

   		    	    variant.Get( flag );

   			   	    result = flag & EActivate;

       			    }

   	            }

  		    variant.Reset();

   		    }

	    }

   	CleanupStack::PopAndDestroy( outList );

   	return result; 

    }	

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

// 

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

//    

void CCPDataManager::BuildChangeInfoL( const CCPLiwMap* aMap, 

        const CLiwDefaultList* aActionTriggers,

		const TLiwGenericParam* aParam,	

		CLiwDefaultList* aChangeInfoList )

	{

	TLiwVariant resultVar = aParam->Value();

    resultVar.PushL();

	if ( resultVar.TypeId() == EVariantTypeMap )

        {

        for ( TInt i = 0; i<aActionTriggers->Count(); i++ )

            {

            CLiwDefaultMap* changeInfoMap = CLiwDefaultMap::NewLC(); 

            CopyVariantL(KId, resultVar.AsMap(), changeInfoMap );

            CopyVariantL(KPublisherId, resultVar.AsMap(), changeInfoMap );

            CopyVariantL(KContentType, resultVar.AsMap(), changeInfoMap );

            CopyVariantL(KContentId, resultVar.AsMap(), changeInfoMap );

            CopyVariantL(KFlag, resultVar.AsMap(), changeInfoMap );

            CopyVariantL(KType, aMap, changeInfoMap );

            TLiwVariant trigger;

            trigger.PushL();

            aActionTriggers->AtL(i,trigger);

            changeInfoMap->InsertL(KActionTrigger, trigger);

            CopyActionTrigger16L(trigger,changeInfoMap);

            CleanupStack::PopAndDestroy(&trigger);

            changeInfoMap->InsertL( KOperation, TLiwVariant( KOperationExecute ) );

            aChangeInfoList->AppendL( TLiwVariant( changeInfoMap ) );

            CleanupStack::PopAndDestroy( changeInfoMap );