// Copyright (c) 2008-2009 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:
//

/**
 @file
 @internalComponent
*/

#include <e32def.h>
#include <e32cmn.h>
#include <hal.h>
#include "EComDebug.h"
#include "ImplementationInformation.h"  // CompareTUidValues
#include "callback.h"
#include "resolvercache.h"
#include "EComPatchDataConstantv2.h"

const TInt KCacheQueueGranularity = 4;

//
// TCounterTicks class
//
inline TCounterTicks::TCounterTicks(TUint aTicks)
	: iTicks(aTicks)
	{
	}

/** This substraction calculate elapsed ticks: aEndTick - this */
inline
TUint TCounterTicks::ElapsedSinceThis(TUint aEndTick) const
	{
	TUint diff;
	if (aEndTick < iTicks) // wrap around occurred
		{
		diff = KMaxTUint - iTicks + aEndTick + 1;
		}
	else
		{
		diff = aEndTick - iTicks;
		}
	return diff;
	}

/** default constructor which initializes all member data to 0. */
RResolverCacheEntry::RResolverCacheEntry()
	: iLastUse( TCounterTicks(0) ), iLruRank(0), iResolverUid(KNullUid),
	iNewLFuncPtr(NULL), iFlags(EEntryFlagsNone)
	{
	iLibrary.SetHandle(KNullHandle);
	}

/** construct RResolverCacheEntry with specific data
@param aResolverUid TUid of the resolver.
@param aLib RLibrary with handle open on the resolver DLL.
@param aNewL Function ptr to instantiate the resolver.
@param aFlags Special conditions about the cache entry.
*/
RResolverCacheEntry::RResolverCacheEntry(const TUid aResolverUid,
										RLibrary aLib,
										TProxyNewLPtr aNewL,
										TUint32 aFlags)
	: iLastUse( TCounterTicks(0) ), iLruRank(0), iResolverUid(aResolverUid),
	iNewLFuncPtr(aNewL), iFlags(aFlags)
	{
	iLibrary.SetHandle(aLib.Handle());
	}

/** unallocate resources owned by the RResolverCacheEntry object */
void RResolverCacheEntry::Close()
	{
	iLibrary.Close();
	}

/** This method compares two RResolverCacheEntry objects.
@param aEntry1 first RResolverCacheEntry object.
@param aEntry2 second RResolverCacheEntry object.
@return 0 means the two objects are equal.
        positive value means first object is greater than the second.
		negative vlaue means second object is greater than the first.
*/
TInt RResolverCacheEntry::CompareUid(const RResolverCacheEntry& aEntry1,
								     const RResolverCacheEntry& aEntry2)
	{
	return CompareTUidValues(aEntry1.iResolverUid.iUid,
							 aEntry2.iResolverUid.iUid);
	}

/** Compare the age of two cache entries.
@param aOther The RResolverCacheEntry to compare with.
@param aCurrTick The current system tick. It simplifies handling
	of system tick wrap around to zero.
@return ETrue means "this" object is older than aOther.
	EFalse means aOther is older than "this".
*/
TBool RResolverCacheEntry::ThisIsOlder(const RResolverCacheEntry& aOther,
										TUint aCurrTick) const
	{
	if (iLastUse.iTicks == aOther.iLastUse.iTicks)
		{
		return iLruRank < aOther.iLruRank;
		}

	// Because of counter wrap around, it is not safe to directly
	// compare the two ticks. Drag in the current system tick.
	return iLastUse.ElapsedSinceThis(aCurrTick) >
			aOther.iLastUse.ElapsedSinceThis(aCurrTick);
	}

//=================================
// CCustomResolverCache class
//=================================

/** CCustomResolverCache constructor
@param aCacheSize Maximum number of entries allowed to cache.
*/
CCustomResolverCache::CCustomResolverCache(TUint32 aCacheSize)
	: CTimer(CActive::EPriorityStandard),
	iResolvers(KCacheQueueGranularity), 
	iMaxCacheSize(aCacheSize)
	{
	}

/** static factory method to instantiate CCustomResolverCache
@param aCacheSize Maximum number of entries allowed to cache.
@param aCacheTimeout Cache timeout in microseconds.
@leave Any of the system wide error codes.
*/
CCustomResolverCache* CCustomResolverCache::NewL(TUint32 aCacheSize, TUint32 aCacheTimeout)
	{
	CCustomResolverCache* self = new (ELeave) CCustomResolverCache(aCacheSize);
	CleanupStack::PushL(self);
	self->ConstructL(aCacheTimeout);
	CleanupStack::Pop(self);
	return self;
	}

/** Standard two phase construction to complete construction of
the CCustomResolverCache object.
@param aCacheTimeout Cache timeout in microseconds.
@leave Any of the system wide error codes.
*/
void CCustomResolverCache::ConstructL(TUint32 aCacheTimeout)
	{
	User::LeaveIfError(HAL::Get(HALData::ESystemTickPeriod,
								iSystemTickPeriod));
	iEntryTimeToLive = (aCacheTimeout + iSystemTickPeriod - 1) / iSystemTickPeriod;

	CTimer::ConstructL();
	CActiveScheduler::Add(this);
	}

/** CCustomResolverCache destructor */
CCustomResolverCache::~CCustomResolverCache()
	{
	Cancel();
	for (TInt i = iResolvers.Count() - 1; i >= 0; i--)
		{
		iResolvers[i].Close();
		}
	iResolvers.Reset();
	}

/** Implement the CActive RunL pure virtual */
void CCustomResolverCache::RunL()
	{
	TUint currTickCount = User::TickCount();
	TUint lruAge = 0;

	for (TInt i = iResolvers.Count() - 1; i >= 0; i--)
		{
		RResolverCacheEntry& resolverEntry = iResolvers[i];
		TUint age = resolverEntry.iLastUse.ElapsedSinceThis(currTickCount);
		if (age >= iEntryTimeToLive)
			{
			resolverEntry.Close();
			iResolvers.Remove(i);
			}
		else if (age > lruAge)
			{
			lruAge = age;
			}
		}

	if (iResolvers.Count() > 0)
		{
		After( iSystemTickPeriod * (iEntryTimeToLive - lruAge + 1) );
		}

#ifdef __ECOMSERVER_TESTING__
	// In unit testing notify test bed that cache timer has fired.
	iTimerExpireCB.CallBack(0, NULL);
#endif
	}

/** Search of a resolver UID in cache
@param aResolverUid the resolver to search for.
@return If find is successful, index of the resolver in RArray of cached resolvers.
		Return KErrNotFound if resolver is not in cache.
*/
TInt CCustomResolverCache::FindResolver(const TUid aResolverUid) const
	{
	RResolverCacheEntry trgt;
	trgt.iResolverUid = aResolverUid;
	TLinearOrder<RResolverCacheEntry> comparator(RResolverCacheEntry::CompareUid);
	return iResolvers.FindInOrder(trgt, comparator);
	}

/** Add a resolver library to cache 
@param aResolverUid Implementation UID of the resolver.
@param aLib	The RLibrary object which has the resolver loaded. The handle
	of the RLibrary is owned by the cache if call is successful.
@param aNewL value for the iNewLFuncPtr member data of RResolverCacheEntry.
@param aFlags value for the iFlags member data of RResolverCacheEntry.
@return KErrNone if the data is added to cache.
	KErrNoMemory if fail to insert the data in RArray.
*/
TInt CCustomResolverCache::CacheResolver(const TUid aResolverUid,
										  RLibrary aLib,
										  TProxyNewLPtr aNewL,
										  TUint32 aFlags)
	{
	if (iResolvers.Count() == iMaxCacheSize)
		{
		EvictLeastRecentlyUsed();
		}

	RResolverCacheEntry entry(aResolverUid, aLib, aNewL, aFlags);
	SetLastUseTime(entry);

#ifdef ECOM_TRACE
	__ECOM_TRACE2("ECOM: adding custom resolver 0x%X to cache. New queue size will be %d.\n", aResolverUid.iUid, 1 + iResolvers.Count());
#endif

	TLinearOrder<RResolverCacheEntry> comparator(RResolverCacheEntry::CompareUid);
	TInt err = iResolvers.InsertInOrder(entry, comparator);

	// if cache was empty before need to start timer
	if (err == KErrNone && ! IsActive())
		{
		After( iSystemTickPeriod * (iEntryTimeToLive + 1) );
		}
	return err;
	}

/** Check if both queue size and cache timeout are non zero  */
TBool CCustomResolverCache::CachingEnabled() const
	{
	return (iMaxCacheSize && iEntryTimeToLive);
	}

/** Remove a cached entry
@param aIndex position of entry in the array.
*/
void CCustomResolverCache::Remove(TInt aIndex)
	{
	iResolvers[aIndex].Close();
	iResolvers.Remove(aIndex);
	}

/** Search for a resolverUID. If found, return the NewL pointer and
update time to live of the entry.
@param aResolverUid the resolver to lookup
@param aNewLFuncPtr output parameter. If lookup successful it has
	the function pointer to instantiate the resolver.
@return True if resolver is in cache. False otherwise.
@post If cache hit, the timestamp of the entry is updated.
*/
TBool CCustomResolverCache::CacheLookup(const TUid aResolverUid,
										TProxyNewLPtr& aNewLFuncPtr)
	{
	TInt i = FindResolver(aResolverUid);
	if (i >= 0)
		{
		aNewLFuncPtr = iResolvers[i].iNewLFuncPtr;
		SetLastUseTime(iResolvers[i]);
		}
	return (i >= 0);
	}

/** Remove a resolver from cache.
@param aResolverUid Identify the resolver to remove.
@return ETrue if aResolverUid is found in cache. EFalse means the
	resolver is not in cache.
*/
TBool CCustomResolverCache::Remove(const TUid aResolverUid)
	{
	TInt i = FindResolver(aResolverUid);
	if (i >= 0)
		{
		Remove(i);
		}
	return (i >= 0);
	}

/** Remove cached entries with flags set.
@param aMask If an entry has any of the bits in aMask set, it is removed.
*/
void CCustomResolverCache::RemoveItemsWithFlags(TUint32 aMask)
	{
	for (TInt i = iResolvers.Count() - 1; i >= 0; i--)
		{
		if (iResolvers[i].iFlags & aMask)
			{
			Remove(i);
			}
		}
	}

/** evict the least recently used entry in cache
*/
void CCustomResolverCache::EvictLeastRecentlyUsed()
	{
	TUint curr = User::TickCount();
	TInt index = 0; // set to first entry in cache.

	for (TInt i = 1; i < iResolvers.Count(); i++)
		{
		RResolverCacheEntry& resolverEntry = iResolvers[i];
		if (resolverEntry.ThisIsOlder(iResolvers[index], curr))
			{
			index = i;
			}
		}

	Remove(index);
	}

/** Set the iLastUse field and iLruRank field of the entry.
The iLruRank field serves as tie breaker when two entries are
added within the same tick period.
@param aEntry The entry to update.
*/
void CCustomResolverCache::SetLastUseTime(RResolverCacheEntry& aEntry)
	{
	TUint curr = User::TickCount();
	aEntry.iLastUse.iTicks = curr;
	aEntry.iLruRank = 0;

	if (curr == iMostRecentTimestamp)
		{
		// There are entries with same timestamp. So have to step
		// through each cache entry to resolve senority.
		for (TInt i = 0; i < iResolvers.Count(); i++)
			{
			RResolverCacheEntry& another = iResolvers[i];
			if (another.iLastUse.iTicks == curr &&
				another.iResolverUid != aEntry.iResolverUid &&
				another.iLruRank >= aEntry.iLruRank)
				{
				aEntry.iLruRank = another.iLruRank + 1;
				}
			}
		}
	else
		{
		iMostRecentTimestamp = curr;
		}
	}