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


#include <cntdb.h>
#include "pbapserver.h"
#include "pbappbhandlecache.h"
#include "btaccesshostlog.h"


/*static*/ CPbapPbHandleCache* CPbapPbHandleCache::NewL(CContactDatabase& aDatabase, MPbHandleCacheObserver& aObserver)
	{
	LOG_STATIC_FUNC
	CPbapPbHandleCache* self=new(ELeave) CPbapPbHandleCache(aDatabase, aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}


CPbapPbHandleCache::CPbapPbHandleCache(CContactDatabase& aDatabase, MPbHandleCacheObserver& aObserver)
	: iDatabase(aDatabase), iObserver(aObserver)
	{
	LOG_FUNC
	}


CPbapPbHandleCache::~CPbapPbHandleCache()
	{
	LOG_FUNC
	iHandleList.Close();
	delete iChangeNotifier;
	}	


void CPbapPbHandleCache::ConstructL()
	{
	LOG_FUNC
	iChangeNotifier = CContactChangeNotifier::NewL(iDatabase, this);
	CreateHandleListL();
	}

	
TInt CPbapPbHandleCache::HandleAtL(TUint aIndex) const
	{
	LOG_FUNC
	if(aIndex >= Count())
		{
		__ASSERT_DEBUG(EFalse, Panic(EPbapServerPanicIndexOutOfBoundry));
		User::Leave(KErrOverflow);
		}
	return iHandleList[aIndex].iHandle;
	}
	
TContactItemId CPbapPbHandleCache::ContactIdAtL(TUint aIndex) const
	{
	LOG_FUNC
	if(aIndex >= Count())
		{
		__ASSERT_DEBUG(EFalse, Panic(EPbapServerPanicIndexOutOfBoundry));
		User::Leave(KErrOverflow);
		}
	return iHandleList[aIndex].iContactId;
	}


TInt CPbapPbHandleCache::FindHandle(TInt aHandle) const
	{
	LOG_FUNC
	// the array is ordered on handle so can use fast binary search
	TPbHandleAndId item(aHandle, KNullContactId);
	return iHandleList.FindInOrder(item, TLinearOrder<TPbHandleAndId>(CompareHandles));
	}


TInt CPbapPbHandleCache::FindContactId(TContactItemId aContactId) const
	{
	LOG_FUNC
	// slow sequential search of array required for contact ids
	TPbHandleAndId item(KErrNotFound, aContactId);
	return iHandleList.Find(item, TIdentityRelation<TPbHandleAndId>(MatchContactIds));
	}


/*static*/
TInt CPbapPbHandleCache::CompareHandles(const TPbHandleAndId& aFirst, const TPbHandleAndId& aSecond)
	{
	LOG_STATIC_FUNC
	return (aFirst.iHandle - aSecond.iHandle);
	}

/*static*/	
TBool CPbapPbHandleCache::MatchContactIds(const TPbHandleAndId& aFirst, const TPbHandleAndId& aSecond)
	{
	LOG_STATIC_FUNC
	return (aFirst.iContactId == aSecond.iContactId);
	}

void CPbapPbHandleCache::CreateHandleListL()
	{
	LOG_FUNC
	
	iHandleList.Reset();
	
	// add own card handle item
	TContactItemId ownCardId = iDatabase.OwnCardId();
	TPbHandleAndId ownCardItem(KOwnCardHandle, ownCardId);
	iHandleList.AppendL(ownCardItem);

	// only include contact cards and the own card when building list
	iDatabase.SetDbViewContactType(KUidContactCard);

	// iterate through database building sorted list of handles
	// (there should be a faster way of getting all the ids in the database,
	// calling CContactDatabase::SortedItemsL() without a sort order used to
	// be the quickest method but that has been deprecated)
	TContactIter iter(iDatabase);
	TContactItemId contactId = iter.FirstL();
	TInt handle = 1;
	while (contactId != KNullContactId)
		{
		if (contactId != ownCardId)
			{
			TPbHandleAndId item(handle, contactId); 
			iHandleList.AppendL(item);
			++handle; // increment handle
			}
		contactId = iter.NextL();
		}
	}

	
void CPbapPbHandleCache::HandleDatabaseEventL(TContactDbObserverEvent aEvent)
	{
	LOG_FUNC
	switch(aEvent.iType)
		{
		case EContactDbObserverEventContactChanged:
			{
			// notify observer that a contact in the cache has changed
			iObserver.HandleCacheChanged();
			}
			break;
		case EContactDbObserverEventContactAdded:
			{
			// add contact id to cache (ignoring insert errors) and notify observer
			HandleContactAddedL(aEvent.iContactId);
			iObserver.HandleCacheChanged();
			}
			break;
		case EContactDbObserverEventContactDeleted:
			{	
			// remove contact id from cache and notify observer 
			HandleContactDeleted(aEvent.iContactId);
			iObserver.HandleCacheChanged();
			}
			break;
		case EContactDbObserverEventOwnCardChanged:
			{
			// the own card has been modified or another contact
			// has been assigned as the own card
			HandleOwnCardChangedL();
			iObserver.HandleCacheChanged();			
			}
			break;
		case EContactDbObserverEventOwnCardDeleted:
			{	
			// reset own card id back to KNullContactId
			HandleOwnCardDeleted();
			iObserver.HandleCacheChanged();
			}
			break;
		case EContactDbObserverEventUnknownChanges:
			{
			// the database has changed but we do not know which
			// contacts were affected, only choice is to rebuild handles cache  
			#ifdef _DEBUG
				TRAPD(error, CreateHandleListL());
				if(error != KErrNone)
					{
					__ASSERT_DEBUG(EFalse, Panic(EPbapServerPanicUnexpectedError));
					User::Leave(error);
					}
			#else
				TRAP_IGNORE(CreateHandleListL());
			#endif // _DEBUG
			iObserver.HandleCacheChanged();
			}
			break;
		default:
			break;
		}
	}


void CPbapPbHandleCache::HandleContactAddedL(TContactItemId aContactId)
	{
	LOG_FUNC
	TPbHandleAndId item(NextAvailableHandleL(), aContactId);
	iHandleList.AppendL(item);
	}

	
void CPbapPbHandleCache::HandleContactDeleted(TContactItemId aContactId)
	{
	LOG_FUNC
	TInt index= FindContactId(aContactId);
	if (index != KErrNotFound)
		{
		iHandleList.Remove(index);
		}
	}


void CPbapPbHandleCache::HandleOwnCardChangedL()
	{
	LOG_FUNC
	TContactItemId ownCardId=iDatabase.OwnCardId();
	TInt ownCardItemIndex = FindHandle(KOwnCardHandle); // always present
	if(ownCardItemIndex == KErrNotFound)
		{
		__ASSERT_DEBUG(EFalse, Panic(EPbapServerPanicOwnCardNotFound));
		User::Leave(KErrNotFound);
		}
	TContactItemId currentOwnCardId = ContactIdAtL(ownCardItemIndex);
	if (ownCardId != currentOwnCardId)
		{
		if (currentOwnCardId != KNullContactId)
			{	
			// current own card now just another contact so assign to a new handle
			TPbHandleAndId item(NextAvailableHandleL(), currentOwnCardId);
			iHandleList.Append(item); // ignore the append error
			}

		// the new own card may already exist in the handle list, if so 
		// remove it
		if (ownCardId != KNullContactId)
			{
			TInt index = FindContactId(ownCardId);
			if (index != KErrNotFound)
				{
				iHandleList.Remove(index);
				}
			}
					
		// replace contact id associated with own card handle
		ownCardItemIndex = FindHandle(KOwnCardHandle);
		iHandleList[ownCardItemIndex].iContactId = ownCardId;
		}			
	}
	

void CPbapPbHandleCache::HandleOwnCardDeleted()
	{
	LOG_FUNC
	// reset own card id to null id
	TInt ownCardItemIndex = FindHandle(KOwnCardHandle);
	iHandleList[ownCardItemIndex].iContactId = KNullContactId;	
	}
	
	
TInt CPbapPbHandleCache::NextAvailableHandleL() const
	{
	LOG_FUNC
	TInt lastHandle = HandleAtL(iHandleList.Count()-1);
	return (lastHandle + 1); // just increment handle
	}