/*

* Copyright (c) 2006 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:   implementation of policy handler

*

*/

#include "alfpolicyhandler.h"

#include "alfpolicyrequesthandler.h"

#include <alflogger.h>

// ======== HELPER CLASS ========

NONSHARABLE_CLASS(TFullScreenBlock)

	{

public:

	TUid iFromUid;

	TUid iToUid;

	};

// ======== MEMBER FUNCTIONS ========

CPolicyHandler* CPolicyHandler::NewL()

    {

    __ALFFXLOGSTRING("CPolicyHandler::NewL >>");

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

    CleanupStack::PushL(self);

    self->iClientRequestHandler = new (ELeave) CPolicyClientRequestHandler(self);

    CleanupStack::Pop(self);

    __ALFFXLOGSTRING("CPolicyHandler::NewL <<");

    return self;

    }

CPolicyHandler::~CPolicyHandler()

    {

    __ALFFXLOGSTRING("CPolicyHandler::~CPolicyHandler >>");

    delete iClientRequestHandler;

    iFullscreenPolicies.ResetAndDestroy();

    iControlPolicies.ResetAndDestroy();

    iFullScreenBlocks.ResetAndDestroy();

    iListBoxPolicies.ResetAndDestroy();

    __ALFFXLOGSTRING("CPolicyHandler::~CPolicyHandler <<");

    }

CPolicyHandler::CPolicyHandler()

    {

    }

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

// Insert the new policy in the list of existing ones.  The list is kept

// sorted according to specificity, ie. how much is specified in the policy.

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

//

void CPolicyHandler::RegisterListBoxKmlL( const TUid& aUid,

										  const TThreadId& aThreadId,

                                          const CAlfTransitionServerClient::TListBoxType aListBoxType,

                                          const TDesC& aResourceDir, 

						                  const TDesC& aBackgroundFilename, 

						                  const TDesC& aItemFilename,

						                  TInt aCachePriority, 

						                  TInt aWantedTime , TInt aMinTime )

    {

    __ALFFXLOGSTRING2("CPolicyHandler::RegisterListBoxKmlL - aUid 0x%x, aThreadId >>", aUid, aThreadId.Id());

	aCachePriority = 1;

	// For now, the cache priority is always 1 at registration time, and after

	// fetching the KML information from the policy, it gets set to 0. This is

	// used to trigger eviction from the KML cache. Newly registered KML:s have

	// priority over existing...

	CListBoxPolicy* policy = CListBoxPolicy::NewL( aUid, 

												   aThreadId, 

												   aListBoxType,

	                                               aResourceDir, 

                                                   aBackgroundFilename, 

                                                   aItemFilename,

                                                   aCachePriority,

                                                   aWantedTime,

                                                   aMinTime );

	CleanupStack::PushL( policy );

	TInt spec = policy->Specificity();	

	TInt count = iListBoxPolicies.Count();

	TInt uid = aUid.iUid;

	TInt i;

	// This keeps the list with ListBox KMLs sorted after specifity, 

	// High specificity is in the beginning of the list and low at the end.

	// This means that when getting a ListBox KML it will find the more specified

	// values first. A Uid counts as more specific than a TListBoxType.

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

	    {

	    CListBoxPolicy* curr = iListBoxPolicies[i];

	    TInt currspec = curr->Specificity();

	    if ( uid == curr->Uid().iUid && aListBoxType == curr->ListBoxType() )

	        {

	        // Duplicate policy, delete the old one.

	        iListBoxPolicies.Remove( i );

	        delete curr;

	        break;

	        }

	    else if ( spec > currspec )

	        {

	        break;

	        }

	    }

    iListBoxPolicies.InsertL( policy, i );

    CleanupStack::Pop();

    __ALFFXLOGSTRING("CPolicyHandler::RegisterListBoxKmlL <<");

	}

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

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

//

TInt CPolicyHandler::UnregisterListBoxKml( const TUid& aUid,

        CAlfTransitionServerClient::TListBoxType aListBoxType )

	{

	__ALFFXLOGSTRING1("CPolicyHandler::UnregisterListBoxKml - Uid: 0x%x >>", aUid);

	for( TInt count = iListBoxPolicies.Count() - 1 ; count >= 0; count-- )

		{

		if( iListBoxPolicies[count]->Uid() == aUid &&

		    iListBoxPolicies[count]->ListBoxType() == aListBoxType )

			{

			delete iListBoxPolicies[count];

			iListBoxPolicies.Remove( count );

			__ALFFXLOGSTRING("CPolicyHandler::UnregisterListBoxKml - return KErrNone<<");

			return KErrNone;

			}

		}

	__ALFFXLOGSTRING("CPolicyHandler::UnregisterListBoxKml - return KErrNotFound <<");

	return KErrNotFound;

	}

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

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

//

TInt CPolicyHandler::UnregisterListBoxKml( const TThreadId& aThreadId )

	{

	__ALFFXLOGSTRING1("CPolicyHandler::UnregisterListBoxKml - aThreadId: %d >>", aThreadId.Id());

	TThreadId tid;

	TInt err = KErrNotFound;

	for( TInt count = iListBoxPolicies.Count() - 1 ; count >= 0; count-- )

		{

		tid = iListBoxPolicies[count]->ThreadId();

		if( tid.Id() == aThreadId.Id() )

			{

			delete iListBoxPolicies[count];

			iListBoxPolicies.Remove( count );

			err = KErrNone;

			}

		}

	__ALFFXLOGSTRING1("CPolicyHandler::UnregisterListBoxKml - return: %d <<", err);

	return err;

	}

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

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

//

TInt CPolicyHandler::GetListBoxKml(	const TUid& aAppId,

                                    const CAlfTransitionServerClient::TListBoxType aListBoxType,

                                    TPtrC& aResourceDir,

                                    TPtrC& aBackgroundFilename, 

                                    TPtrC& aItemFilename, 

                                    TInt& aCachePriority, TInt& aWantedTime,

									TInt& aMinTime)

	{

	__ALFFXLOGSTRING3("CPolicyHandler::GetListBoxKml - aResourceDir: %S, aBackgroundFilename: %S, aItemFilename: %S >>", &aResourceDir, &aBackgroundFilename, &aItemFilename);

	TInt count = iListBoxPolicies.Count();

	TBool hit = EFalse;

	TInt i;

    aResourceDir.Set( TPtrC() );

    aBackgroundFilename.Set( TPtrC() );

    aItemFilename.Set( TPtrC() );

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

        {

        CListBoxPolicy* curr = iListBoxPolicies[i];

        TInt uid = curr->Uid().iUid;

        CAlfTransitionServerClient::TListBoxType listType = curr->ListBoxType();

        if ( ( !uid || uid == aAppId.iUid ) &&

             ( listType == CAlfTransitionServerClient::EListTypeAny ||

               listType == aListBoxType ) )

            {

            hit = ETrue;

            break;

            }

        }

    if ( !hit )

        {

        __ALFFXLOGSTRING("CPolicyHandler::GetListBoxKml - return KErrNotFound <<");

        return KErrNotFound;

        }

	aResourceDir.Set( iListBoxPolicies[i]->ResourceDir() );

	aBackgroundFilename.Set( iListBoxPolicies[i]->BackgroundFilename() );

	aItemFilename.Set( iListBoxPolicies[i]->ItemFilename() );

	aCachePriority = iListBoxPolicies[i]->CachePriority();

	aWantedTime = iListBoxPolicies[i]->WantedTime();

	aMinTime = iListBoxPolicies[i]->MinTime();

	// For now, this entry should have no priority over others

	iListBoxPolicies[i]->SetCachePriority( 0 );

	__ALFFXLOGSTRING("CPolicyHandler::GetListBoxKml - return KErrNone <<");

	return KErrNone;

	}

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

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

//

void CPolicyHandler::RegisterFullscreenKmlL(TUint aAction, const TUid& aUid, const TThreadId& aThreadId,

											const TDesC& aResourceDir, const TDesC& aFilename,

											TInt /*aCachePriority*/, TInt aWantedTime, TInt aMinTime)

	{

	__ALFFXLOGSTRING3("CPolicyHandler::RegisterFullscreenKmlL - aAction: %d aUid: 0x%x aThread.Id : %d", aAction, aUid, aThreadId.Id() );

	__ALFFXLOGSTRING2("CPolicyHandler::RegisterFullscreenKmlL - aResourceDir: %S, aFilename: %S", &aResourceDir, &aFilename );

	TInt cachePriority = 1; //aCachePriority; 

	// For now, the cache priority is always 1 at registration time, and after

	// fetching the KML information from the policy, it gets set to 0. This is

	// used to trigger eviction from the KML cache. Newly registered KML:s have

	// priority over existing...

	CFullscreenPolicy* policy = NULL;

	// Check if the action was already is registered and if so, delete it.

	TInt count = iFullscreenPolicies.Count()-1;

	for(; count >= 0; count--)

		{

		if(	iFullscreenPolicies[count]->Action() == aAction && 

			iFullscreenPolicies[count]->Uid() == aUid)

			{

			policy = iFullscreenPolicies[count];

			iFullscreenPolicies.Remove(count);

			delete policy;

			policy = NULL;

			}

		} 

	// create and add the new action.

	policy = CFullscreenPolicy::NewL(aAction, aUid, aThreadId, aResourceDir, aFilename,

														cachePriority, aWantedTime, aMinTime);

	CleanupStack::PushL(policy);

	iFullscreenPolicies.AppendL(policy);

	CleanupStack::Pop(policy);

	__ALFFXLOGSTRING("CPolicyHandler::RegisterFullscreenKmlL <<");

	}

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

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

//

TInt CPolicyHandler::UnregisterFullscreenKml(TUint aAction, const TUid& aUid)

	{

	__ALFFXLOGSTRING2("CPolicyHandler::UnregisterFullscreenKml - aAction: %d, aUid: 0x%x <<", aAction, aUid );

	TInt count = iFullscreenPolicies.Count() -1;

	for(; count >= 0; count--)

		{

		if(iFullscreenPolicies[count]->Action() == aAction && 

			iFullscreenPolicies[count]->Uid() == aUid)

			{

			CFullscreenPolicy* policy = iFullscreenPolicies[count];

			iFullscreenPolicies.Remove(count);

			delete policy;

			policy = NULL;

			__ALFFXLOGSTRING("CPolicyHandler::UnregisterFullscreenKml - return KErrNone <<");

			return KErrNone;

			}

		}

	__ALFFXLOGSTRING("CPolicyHandler::UnregisterFullscreenKml - return KErrNotFound <<");

	return KErrNotFound;

	}

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

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

//

TInt CPolicyHandler::UnregisterFullscreenKml(const TThreadId& aThreadId)

	{

	__ALFFXLOGSTRING1("CPolicyHandler::UnregisterFullscreenKml - aThreadId: %d >>", aThreadId.Id());

	TInt count = iFullscreenPolicies.Count() -1;

	TInt err = KErrNotFound;

	TThreadId tid;

	for(; count >= 0; count--)

		{

		tid = iFullscreenPolicies[count]->ThreadId();

		if( tid.Id() == aThreadId.Id())

			{

			CFullscreenPolicy* policy = iFullscreenPolicies[count];

			iFullscreenPolicies.Remove(count);

			delete policy;

			policy = NULL;

			err = KErrNone;

			}

		}

	__ALFFXLOGSTRING1("CPolicyHandler::UnregisterFullscreenKml - return: %d <<", err);

	return err;

	}

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

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

//

TInt CPolicyHandler::UnregisterAllKml(const TThreadId& aThreadId)

	{

	__ALFFXLOGSTRING1("CPolicyHandler::UnregisterAllKml - aThreadId: <<", aThreadId.Id());

	TInt err = KErrNotFound;

	TInt err1 = UnregisterFullscreenKml(aThreadId);

	TInt err2 = UnregisterControlKml(aThreadId);

	if(err1 == KErrNone || err2 == KErrNone)

		err = KErrNone;

	TInt err3 = UnregisterListBoxKml(aThreadId);

	if(err3 == KErrNone)

		err = KErrNone;

	__ALFFXLOGSTRING1("CPolicyHandler::UnregisterAllKml - return: %d <<", err);

    return err; 

    }

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

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

//

TInt CPolicyHandler::GetFullscreenKml(	TUint aAction, const TUid& aToUid, const TUid& aFromUid,

									 	TPtrC& aResourceDir, TPtrC& aFilename,

									 	TInt& aCachePriority, TInt& aWantedTime, TInt& aMinTime)

	{

    __ALFFXLOGSTRING3("CPolicyHandler::GetFullscreenKml - aAction: %d, aToUid: %d, aFromUid :%d", aAction, aToUid, aFromUid );

    __ALFFXLOGSTRING2("CPolicyHandler::GetFullscreenKml - aResourceDir: %S, aFilename :%S", &aResourceDir, &aFilename );

	// Checking if the UID is blocked.

	TInt blockedUids = iFullScreenBlocks.Count();

	aResourceDir.Set( TPtrC() );

	aFilename.Set( TPtrC() );

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

		{

		if( iFullScreenBlocks[i]->iToUid == aToUid ||

			iFullScreenBlocks[i]->iFromUid == aFromUid)

			{

			__ALFFXLOGSTRING("CPolicyHandler::GetFullscreenKml - return KErrNotSupported <<");

			return KErrNotSupported;

			}

		}

	TInt count = iFullscreenPolicies.Count();

	// try to find it using both action and uid

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

		{

		if(iFullscreenPolicies[i]->Action() == aAction && 

			iFullscreenPolicies[i]->Uid() == aToUid)

			{

			aResourceDir.Set( iFullscreenPolicies[i]->ResourceDir() );

			aFilename.Set( iFullscreenPolicies[i]->Filename() );

			aCachePriority = iFullscreenPolicies[i]->CachePriority();

			aWantedTime = iFullscreenPolicies[i]->WantedTime();

			aMinTime = iFullscreenPolicies[i]->MinTime();

			// Check if theres a block on this UID/Action pair.

			if( aFilename.Length() == 0 ) 

				{

	            __ALFFXLOGSTRING("CPolicyHandler::GetFullscreenKml - return KErrNotSupported <<");

				return KErrNotSupported;

				}

			// For now, this entry should have no priority over others

			iFullscreenPolicies[i]->SetCachePriority(0);

            __ALFFXLOGSTRING("CPolicyHandler::GetFullscreenKml - return KErrNone <<");

            return KErrNone;

			}

		}

	// try to find the default (Uid == KNullUid)

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

		{

		if(iFullscreenPolicies[i]->Action() == aAction && 

			iFullscreenPolicies[i]->Uid() == KNullUid)

			{

			aResourceDir.Set( iFullscreenPolicies[i]->ResourceDir() );

			aFilename.Set( iFullscreenPolicies[i]->Filename() );

			aCachePriority = iFullscreenPolicies[i]->CachePriority();

			aWantedTime = iFullscreenPolicies[i]->WantedTime();

			aMinTime = iFullscreenPolicies[i]->MinTime();

			// For now, this entry should have no priority over others

			iFullscreenPolicies[i]->SetCachePriority(0); 

			__ALFFXLOGSTRING("CPolicyHandler::GetFullscreenKml - return KErrNone <<");

			return KErrNone;

			}

		}

	__ALFFXLOGSTRING("CPolicyHandler::GetFullscreenKml - return KErrNotFound <<");

	return KErrNotFound;

	}

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

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

//

TInt CPolicyHandler::BlockFullScreenUid(const TUid& aUid, TBool aBlockFrom, TBool aBlockTo)

	{

	__ALFFXLOGSTRING3("CPolicyHandler::BlockFullScreenUid - aUid: 0x%x, aBlockFrom: %d, aBlockTo: %d >>", aUid, aBlockFrom, aBlockTo );	

	TFullScreenBlock* block = NULL;

	TInt blockedUids = iFullScreenBlocks.Count();

	if(	blockedUids > 0)

		{

		// Looking for an existing To block.

		if(!aBlockTo && aBlockFrom )

			{

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

				{

				if(iFullScreenBlocks[i]->iFromUid == aUid)

					{

					__ALFFXLOGSTRING("CPolicyHandler::BlockFullScreenUid - return KErrNone <<");

					return KErrNone;

					}

				}

			}

		// Looking for an existing From block.

		else if(aBlockTo && !aBlockFrom)

			{

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

				{

				if(iFullScreenBlocks[i]->iToUid  == aUid)

					{

					__ALFFXLOGSTRING("CPolicyHandler::BlockFullScreenUid - return KErrNone <<");

					return KErrNone;

					}

				}

			}

		// Trying to unblock stuff.

		else if(!aBlockTo && !aBlockFrom)

			{

			for(TInt i = blockedUids -1; i >= 0; i--)

				{

				if(	iFullScreenBlocks[i]->iToUid  == aUid ||

					iFullScreenBlocks[i]->iFromUid == aUid )

					{

					block = iFullScreenBlocks[i];

					iFullScreenBlocks.Remove(i);

					delete block;

					block = NULL;

					}

				}

			__ALFFXLOGSTRING("CPolicyHandler::BlockFullScreenUid - return KErrNone <<");

			return KErrNone;

			}

		// Looking for an existing To and From block with the same UID's.

		else

			{

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

				{

				if(	iFullScreenBlocks[i]->iToUid  == aUid &&

					iFullScreenBlocks[i]->iFromUid == aUid )

					{

					__ALFFXLOGSTRING("CPolicyHandler::BlockFullScreenUid - return KErrNone <<");

					return KErrNone;

					}

				}

			}

		}

	// None found. Create!

	block = new TFullScreenBlock();

	if(NULL == block)

		{

		__ALFFXLOGSTRING("CPolicyHandler::BlockFullScreenUid - return KErrNoMemory <<");

		return KErrNoMemory;

		}

	if(aBlockTo)

		{

		block->iToUid = aUid;

		}

	if(aBlockFrom)

		{

		block->iFromUid = aUid;

		}

	TInt err = iFullScreenBlocks.Append(block);

	if(KErrNone != err)

		{

		delete block;

		block = NULL;

		}

	__ALFFXLOGSTRING1("CPolicyHandler::BlockFullScreenUid - return: %d <<", err);

	return err;

	}

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

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

//

TInt CPolicyHandler::RegisterControlAction(const TUid aUid, TUint aAction, const TDesC& aActionString)

	{

	__ALFFXLOGSTRING3("CPolicyHandler::RegisterControlAction - aUid: 0x%x, aAction: %d, aActionString: %S", aUid, aAction, &aActionString );

	TInt index = 0;

	CControlPolicy* pData = NULL;

	CActionPolicy* pPolicy = NULL;

	// TEST!!!!!!!!!!

	// First see if we have an empty entry that means a new KML has been registered

	// Adding just a KML does not remove the old one, the old one gets removed only

	// after we add an action to the new KML

	// The double action of first registering a KML file and then registering the action

	// should be replaced with single call where the control file and action are defined

	// in one call

    TInt count = iControlPolicies.Count();

	index = -1;	// Setting index to negative value to use as check if match found.

	TInt i = 0;