/*

* Copyright (c) 2010 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 "cmdnscachemap.h"

#include "mdnsrecordinfo.h"

#include <mdns/crdtypesrv.h>

#include <mdns/crdtypea.h>

#include <mdns/crdtypeptr.h>

#include <mdns/crdtypetxt.h>

__FLOG_STMT(_LIT8(KComponent,"MDNSCache");)

CMDNSCacheMap* CMDNSCacheMap::NewL(TUint aMaxCacheEntries)

	{

	CMDNSCacheMap* self = CMDNSCacheMap::NewLC(aMaxCacheEntries);

	CleanupStack::Pop(self);

	return self;

	}

CMDNSCacheMap* CMDNSCacheMap::NewLC(TUint aMaxCacheEntries)

	{

	CMDNSCacheMap* self = new (ELeave)CMDNSCacheMap(aMaxCacheEntries);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CMDNSCacheMap::ConstructL()

	{

	__FLOG_OPEN(KMDNSSubsystem, KComponent);

	__FLOG(_L8("ConstructL - Entry"));

	__FLOG(_L8("ConstructL - Exit")); 

	}

CMDNSCacheMap::CMDNSCacheMap(TUint aMaxCacheEntries):iCacheEntries(HashInfo::TPtrC8Hash,HashInfo::TPtrC8Ident),iterate(iCacheEntries)

	{

	iMaxCacheEntries = aMaxCacheEntries;

	}

CMDNSCacheMap::~CMDNSCacheMap()

	{

	__FLOG(_L8("Destructor - Entry"));

	RHashMap<TPtrC8,CServiceInfo*>::TIter iter(iCacheEntries);

	TInt count(0);

	TInt entriesToDelete(iCacheEntries.Count());

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

		{

		 delete *iter.NextValue();

		}

	iCacheEntries.Close();

	__FLOG(_L8("Destructor - Exit"));

	__FLOG_CLOSE;

	}

TUint32 HashInfo::TPtrC8Hash(const TPtrC8& aPtr)

	{

	return DefaultHash::Des8(aPtr);

	}

TBool HashInfo::TPtrC8Ident(const TPtrC8& aL, const TPtrC8& aR)

	{

	return DefaultIdentity::Des8(aL, aR);

	}

void CMDNSCacheMap::UpdateL(const TDesC8& aName, CServiceInfo* aEntry)

	{

	__FLOG(_L8("Insert - Entry"));

	TTime currentTime;

	currentTime.UniversalTime();

	aEntry->SetAccessTime(currentTime);

	TBool authoritative = aEntry->IsAuthoritative();

	//Save the key

	aEntry->SetKeyL(aName);

	if(NumberOfEntries()<=iMaxCacheEntries)

		{

		iCacheEntries.InsertL(aEntry->Key(),aEntry);

		}

	else

	{

		if(aEntry->IsAuthoritative() && DeleteLeastRecentlyUsed())

			{

			iCacheEntries.InsertL(aEntry->Key(),aEntry);		

			}

		else

			{

			delete aEntry;

			__FLOG_VA((_L8("--------User::Leave on Insert  = %d--------"),KErrNoMemory));

			User::Leave(KErrNoMemory);

			}

		}

	__FLOG(_L8("Insert - Exit"));

	}

CServiceInfo* CMDNSCacheMap::Find(const TDesC8& aName)

	{

	TTime currentTime;

	RBuf8 key;

	key.CreateL(aName);

	//All keys are in LowerCase

	key.LowerCase();

	CServiceInfo** foundEntry = NULL;	

	foundEntry = iCacheEntries.Find(key);

	key.Close();

	currentTime.UniversalTime();

	if(foundEntry)

		{		

		(*foundEntry)->SetAccessTime(currentTime);

		return *foundEntry;

		}	

	return NULL;	

	}

void CMDNSCacheMap::FindEntries(const TDesC8& aName,RPointerArray <const CServiceInfo> & aEntries)

	{	

	_LIT8(KRegExp,"*");

	TInt error; 

	TBuf8 <256> serviceType(KRegExp);

	TTime currentTime;

	serviceType.Append(aName);

	THashMapIter<TPtrC8,CServiceInfo*> iter(iCacheEntries);

    TInt count;

     for(count=0; count<iCacheEntries.Count(); count++)

         {                        

         TPtrC8 nextKey=*iter.NextKey();

         //Match by the regular expression to get all Services by type

         error=nextKey.MatchF(serviceType);

         if( error != KErrNotFound)

        	 {

        	 CServiceInfo* currentEntry= *iter.CurrentValue();

        	 aEntries.Append(currentEntry);

        	 currentTime.UniversalTime();

        	 currentEntry->SetAccessTime(currentTime);

        	 }         

         }

	}

/*Not Used : Currently*/

void CMDNSCacheMap::AuthoritativeRecordsL(RPointerArray <const CServiceInfo> & aEntries)

	{

	THashMapIter<TPtrC8,CServiceInfo*> iter(iCacheEntries);

    TInt count;

    TTime currentTime;

     for(count=0; count<iCacheEntries.Count(); count++)

         {                        

         CServiceInfo* entry=*iter.NextValue();

         if(entry->IsAuthoritative())

        	 {

        	 aEntries.AppendL(entry);

        	 currentTime.UniversalTime();

        	 entry->SetAccessTime(currentTime);

        	 }         

         }

	}

TInt CMDNSCacheMap::DeleteL(const TDesC8& aName)

	{

	__FLOG(_L8("CMDNSCacheMap::DeleteL - Entry"));	

	TInt error = KErrNone;

	TBuf8 <256> key(aName);

	//All keys are in LowerCase

	key.LowerCase();

    #ifdef __FLOG_ACTIVE

        HBufC8* buf(HBufC8::NewLC(aName.Length()));

        buf->Des().Copy(aName); 

        __FLOG_VA((_L8("Deleted Entry = %S "),buf));        

        CleanupStack::PopAndDestroy(buf);

    #endif

	CServiceInfo* entryToDelete = NULL;

	TRAPD(err,entryToDelete=iCacheEntries.FindL(key));

	if(err!=KErrNotFound)

	    {

	    error = iCacheEntries.Remove(key);

	    delete entryToDelete;

	    __FLOG(_L8("CMDNSCacheMap::DeleteL - Delete Cache Entry Successful"));  

	    __FLOG(_L8("CMDNSCacheMap::DeleteL - Exit"));

	    }

	else

	    {

	    __FLOG(_L8("CMDNSCacheMap::DeleteL - Entry not found in Cache"));

	    }

	return error;

	}

void CMDNSCacheMap::DeleteAllEntries()

	{

	THashMapIter<TPtrC8,CServiceInfo*> iter(iCacheEntries);

	TInt count;

	for(count=0; count<iCacheEntries.Count(); count++)

		{                        

		TPtrC8 key=*iter.NextKey();

		/*TODO: check if object is properly deleted;

		 * destructors are called*/

		iCacheEntries.Remove(key);

		delete *iter.NextValue();

		}

	}

/* Scenarios:

1. All are authoritative in Cache, authoritative record comes for insertion : No Memory

2. All are authoritative in Cache, non-authoritative comes : No Memory

3. One or more non-authoritative, non-authoritative comes : No Memory

4. All are non-authoritative,authoritative comes, one of the records 

	based on LRU (not accurate)of which is deleted, but authoritative WILL BE 

   put into cache

  */

TBool CMDNSCacheMap::DeleteLeastRecentlyUsed()

	{

	THashMapIter<TPtrC8,CServiceInfo*> iter(iCacheEntries);

	TInt count;

	TTime accessTime,timeOfLRUEntry;

	CServiceInfo* entryToDelete = NULL;

	TBuf8<255> keyToDelete;

	TBool cacheFull = ETrue;

	for(count=0; count<iCacheEntries.Count(); count++)

		{                                 

		CServiceInfo* nextEntry = *iter.NextValue();

		accessTime = nextEntry->LastAccessTime();

		if(count==0)

			{

			timeOfLRUEntry = accessTime;

			if(!nextEntry->IsAuthoritative())

				{

				keyToDelete = *iter.CurrentKey();

				entryToDelete = nextEntry;

				}

			}

		else

		  {

		 	if((accessTime < timeOfLRUEntry) && !nextEntry->IsAuthoritative() )

		 		{

		 		timeOfLRUEntry = accessTime;

		 		keyToDelete = *iter.CurrentKey();

				entryToDelete = nextEntry;

		 		}		 	

		  }

		}

	TInt error = iCacheEntries.Remove(keyToDelete);	

	if(error !=  KErrNone)

		{

		cacheFull =  EFalse;								

		}

	else

	{

	#ifdef __FLOG_ACTIVE

		__FLOG_VA((_L8("Deleting Least Recently Used = %S "),&keyToDelete));

	#endif

	}

	delete entryToDelete;

	return cacheFull;

	}

TUint32 CMDNSCacheMap::NumberOfEntries()

	{

	return iCacheEntries.Count();

	}

CServiceInfo* CMDNSCacheMap::NextStaleEntry(TBool aActiveCacheMgmtEnabled,TBool aIteratorReset)

	{

/*

	 if(aIteratorReset)

	 	{

	 	iterate.Reset();

	 	}

	 CServiceInfo* nextEntry=*iterate.NextValue();

	 if(nextEntry->EntryExpired() || nextEntry->EntryToBeQueried())

	 	{

	 	__FLOG(_L8("Stale Entry Found"));

	 	return nextEntry;

	 	}

	 return NULL;

*/

    THashMapIter<TPtrC8,CServiceInfo*> itr(iCacheEntries);

	CServiceInfo*const* nextEntry=itr.NextValue();

	while(nextEntry!=NULL)

	    {

        if((*nextEntry)->EntryExpired())

            {

            __FLOG(_L8("Stale Entry Found"));

            return (*nextEntry);

            }	    

        nextEntry=itr.NextValue();

	    }

	return NULL;

    }

void CMDNSCacheMap::DumpCacheL()

	{

	RHashMap<TPtrC8,CServiceInfo*>::TIter iter(iCacheEntries);

	__FLOG(_L8("!!!!!!!!!!!!!!!!!!   BEGIN  CACHE DUMP   !!!!!!!!!!!!!!!!!!!!!"));

	for(TInt count=0; count<iCacheEntries.Count(); count++)

		{

		CServiceInfo* entry = *iter.NextValue();

		__FLOG_VA((_L8("--------------------Begin Entry = %d------------------"),count));	

		TPtrC8 key(*iter.CurrentKey());

		__FLOG_VA((_L8("--------------------Key is = %S------------------"),&key));

		if(entry->ServiceRecord())

			{

			__FLOG(_L8("--------Service-Record Data-----"));

			HBufC8* buf(HBufC8::NewLC(entry->ServiceRecord()->Name().Length()));

			buf->Des().Copy(entry->ServiceRecord()->Name());

			__FLOG_VA((_L8("Service Name = %S "),buf));	

			HBufC8* target(HBufC8::NewLC(entry->ServiceRecord()->Target().Length()));

			target->Des().Copy(entry->ServiceRecord()->Target());

			__FLOG_VA((_L8("Target Machine = %S "),target));

			__FLOG_VA((_L8("Priority = %d "),entry->ServiceRecord()->Priority()));

			__FLOG_VA((_L8("Port = %d "),entry->ServiceRecord()->Port()));

			__FLOG_VA((_L8("TTL = %d "),entry->ServiceRecord()->Ttl()));

			CleanupStack::PopAndDestroy(target);

			CleanupStack::PopAndDestroy(buf);

			}

		if(entry->AddressRecord())

			{

			__FLOG(_L8("-------Address-Record Data--------"));

			HBufC8* buf(HBufC8::NewLC(entry->AddressRecord()->Name().Length()));

			buf->Des().Copy(entry->AddressRecord()->Name());

			__FLOG_VA((_L8("Host Name = %S "),buf));		

			const TInetAddr addr(entry->AddressRecord()->Address());

			TBuf <255> ipaddr;

			addr.Output(ipaddr);

			__FLOG_VA((_L("Inet Address = %S "),&ipaddr));

			__FLOG_VA((_L8("TTL = %d "),entry->AddressRecord()->Ttl()));

			CleanupStack::PopAndDestroy(buf);

			}

		if(entry->PtrRecord())

			{

			__FLOG(_L8("-------Ptr-Record Data-----------"));

			HBufC8* buf(HBufC8::NewLC(entry->PtrRecord()->Name().Length()));

			buf->Des().Copy(entry->PtrRecord()->Name());

			__FLOG_VA((_L8("PTR  Name= %S "),buf));

			HBufC8* domainName(HBufC8::NewLC(entry->PtrRecord()->DomainName().Length()));

			domainName->Des().Copy(entry->PtrRecord()->DomainName());

			__FLOG_VA((_L8("PTR Domain Name = %S "),domainName));	

			__FLOG_VA((_L8("Type = %d "),entry->PtrRecord()->Type()));

			__FLOG_VA((_L8("TTL = %d "),entry->PtrRecord()->Ttl()));

			CleanupStack::PopAndDestroy(domainName);

			CleanupStack::PopAndDestroy(buf);

			}

		if(entry->TxtRecord())

			{

			__FLOG(_L8("--------Txt-Record Data---------"));

			const RArray <RBuf8>& array = entry->TxtRecord()->Text();

			HBufC8* name(HBufC8::NewLC(entry->TxtRecord()->Name().Length()));

			name->Des().Copy(entry->TxtRecord()->Name());

			__FLOG_VA((_L8("Text Name= %S "),name));

			CleanupStack::PopAndDestroy(name);

			for (TInt count=0;count<array.Count();count++)

				{

				HBufC8* text(HBufC8::NewLC(array[count].Length()));

				text->Des().Copy(array[count]);

				__FLOG_VA((_L8("Text Info = %S "),text));

				CleanupStack::PopAndDestroy(text);			

				}			

			__FLOG_VA((_L8("TTL = %d "),entry->TxtRecord()->Ttl()));

			}

		__FLOG_VA((_L8("--------Entry is Authoritative?? = %d--------"),entry->IsAuthoritative()));				

		__FLOG_VA((_L8("--------Last Access Time = %ld--------"),entry->LastAccessTime()));

		}

	__FLOG_VA((_L8("--------Total number of entries = %d--------"),iCacheEntries.Count()));

	}