// 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:
// cmdnsconsistencymgr.cpp
// 
//
/**
@file
@internalTechnology
*/

//User include
#include "cmdnscacheconsistencymgr.h"
#include "cmdnscachemanager.h"
#include "cmessagehandler.h"

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


const TUint32 KMinActivityCount = 5;//TODO: to Define correct Min Work Count


/*
 * Two phase constructor
 * @param aActiveCacheMgmtEnabled
 * @param aMessageHandler reference to message handler.
 */
 CMDNSCacheConsistencyMgr* CMDNSCacheConsistencyMgr::NewL(TBool aActiveCacheMgmtEnabled,CMessageHandler& aMessageHandler)
	{
	CMDNSCacheConsistencyMgr* self = CMDNSCacheConsistencyMgr::NewLC(aActiveCacheMgmtEnabled,aMessageHandler);
	CleanupStack::Pop(self);
	return self;
	}

/*
 * Two phase constructor
 * @param aActiveCacheMgmtEnabled
 * @param aMessageHandler reference to message handler.
 */
CMDNSCacheConsistencyMgr* CMDNSCacheConsistencyMgr::NewLC(TBool aActiveCacheMgmtEnabled,CMessageHandler& aMessageHandler)
	{
	CMDNSCacheConsistencyMgr* self = new (ELeave)CMDNSCacheConsistencyMgr(aActiveCacheMgmtEnabled,aMessageHandler);
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

/*
 * Constructor.
 */
CMDNSCacheConsistencyMgr::CMDNSCacheConsistencyMgr(TBool aActiveCacheMgmtEnabled,CMessageHandler& aMessageHandler)
:CActive(EPriorityStandard),iMessageHandler(aMessageHandler)
	{
	iActiveCacheMgmtEnabled=aActiveCacheMgmtEnabled;
	iWalkInterval= KDefaultCheckInterval;
	CActiveScheduler::Add(this);	
	}


//Destructor
CMDNSCacheConsistencyMgr::~CMDNSCacheConsistencyMgr()
	{
	__FLOG(_L8("CMDNSCacheConsistencyMgr::~CMDNSCacheConsistencyMgr - Entry"));
	iTimer.Close();
	__FLOG(_L8("CMDNSCacheConsistencyMgr::~CMDNSCacheConsistencyMgr - Exit"));
	__FLOG_CLOSE;
	}
/*
 * Two phase constructor
 */
void CMDNSCacheConsistencyMgr::ConstructL()
	{
	__FLOG_OPEN(KMDNSSubsystem, KComponent);
	__FLOG(_L8("CMDNSCacheConsistencyMgr::ConstructL - Entry"));
	User::LeaveIfError(iTimer.CreateLocal());	
	__FLOG(_L8("CMDNSCacheConsistencyMgr::ConstructL - Exit"));
	}

/*
 * Function to stop running the consistemcy manager .
 * Cancels all the asynchronous request.
 */
void CMDNSCacheConsistencyMgr::Stop()
	{
	__FLOG(_L8("CMDNSCacheConsistencyMgr::Stop - Entry"));
	Cancel();
	__FLOG(_L8("CMDNSCacheConsistencyMgr::Stop - Exit"));
	}
	
/*
 * Starts the consistency Manager
 * @param aWalkInterval specifies the walk interval in seconds.
 */	
void CMDNSCacheConsistencyMgr::Start(TUint aWalkInterval)
	{
	__FLOG(_L8("CMDNSCacheConsistencyMgr::Start - Entry"));
	iWalkInterval = aWalkInterval;
	TUint Interval= iWalkInterval*1000000;
	//Converted to Microseconds		
	iTimer.After(iStatus,Interval);
	SetActive();
	__FLOG(_L8("CMDNSCacheConsistencyMgr::Start - Exit"));
	}
/*
 * Delay between two Walk thourgh .
 * Starts a time to complete the request after an interval mentioned in the iWalkinterval.
 * @param aStatus reference to status variable.
 */
 void CMDNSCacheConsistencyMgr::Delay(TRequestStatus& aStatus)
	{
	__FLOG(_L8("CMDNSCacheConsistencyMgr::Delay - Entry"));
	TUint Interval= iWalkInterval*1000000;
	//Converted to Microseconds		
	iTimer.After(aStatus,Interval);
	SetActive();
	__FLOG(_L8("CMDNSCacheConsistencyMgr::Delay - Exit"));
	}


 /*
  * Iterates the cache on each hit
  * and sets a delay for the nexthit.
  */
void CMDNSCacheConsistencyMgr::RunL()
	{	
	__FLOG(_L8("CMDNSCacheConsistencyMgr::RunL - Entry"));
	IterateCacheL();
	Delay(iStatus);
	__FLOG(_L8("CMDNSCacheConsistencyMgr::RunL - Exit"));
	}

/*
 * Handles any leave at RunL
 * 
 */
TInt CMDNSCacheConsistencyMgr::RunError(TInt aError)
	{
	__FLOG(_L8("CMDNSCacheConsistencyMgr::RunError - Entry"));
	User::LeaveIfError(aError);
	return aError;
	__FLOG(_L8("CMDNSCacheConsistencyMgr::RunError - Exit"));
	}

/*
 * Cancels any asynchoronous request.
 */
void CMDNSCacheConsistencyMgr::DoCancel()
	{
	__FLOG(_L8("CMDNSCacheConsistencyMgr::DoCancel - Entry"));
	iTimer.Cancel();
	__FLOG(_L8("CMDNSCacheConsistencyMgr::DoCancel - Exit"));
	}
	
/*
 * Walk through the cache .Does two function
 * 1. Publish any authoritative entries.
 * 2. Query for the enteries if not authoritative.
 */
void CMDNSCacheConsistencyMgr::IterateCacheL()	
	{	
	__FLOG(_L8("CMDNSCacheConsistencyMgr::IterateCacheL - Entry"));
	TBool iterateReset(ETrue);
	TBool cacheUpToDate(ETrue);
	TInt count = iMessageHandler.DnsCache().NumberOfEntries();
	TInt index(0);
	
	
		
	for(index=0; index<count;index++)
		{
		//Fetch the next entry whose ttl has completely expired or 80% 
		//of ttl has expired 
		CCacheEntry* entry = iMessageHandler.DnsCache().NextStaleEntry(iActiveCacheMgmtEnabled,iterateReset);

		//Reset the iterate flag
		iterateReset = EFalse;
	    __FLOG(_L8("CMDNSCacheConsistencyMgr::IterateCacheL - 1"));
		if(entry)
			{
			if(entry->EntryExpired())
				{
				
				if(entry->IsAuthoritative())
					{
					//Republish the record
					//Goodbye packet is sent while the session for publish is closed
					CDnsMessage * announcement = CDnsMessage::NewL(0,EFalse);
					CleanupStack::PushL(announcement);
					if(entry->PtrRecord())
					    {
                        entry->PtrRecord()->SetTtl(120);
					    announcement->AppendAnswerL(entry->PtrRecord()->CloneL());
					    iMessageHandler.DnsCache().UpdateCacheL(*(entry->PtrRecord()),ETrue,entry->SessionId());
                        __FLOG(_L8("CMDNSCacheConsistencyMgr::IterateCacheL - 2"));
					    }
					if(entry->ServiceRecord())
					    {
                        entry->ServiceRecord()->SetTtl(120);
					    announcement->AppendAnswerL(entry->ServiceRecord()->CloneL());
					    iMessageHandler.DnsCache().UpdateCacheL(*(entry->ServiceRecord()),ETrue,entry->SessionId());
					    __FLOG(_L8("CMDNSCacheConsistencyMgr::IterateCacheL - 3"));
					    }
					if(entry->TxtRecord())
					    {
                        entry->TxtRecord()->SetTtl(120);
					    announcement->AppendAnswerL(entry->TxtRecord()->CloneL());
					    iMessageHandler.DnsCache().UpdateCacheL(*(entry->TxtRecord()),ETrue,entry->SessionId());
					    __FLOG(_L8("CMDNSCacheConsistencyMgr::IterateCacheL - 4"));
					    }
					if(entry->AddressRecord())
                        {
                        entry->AddressRecord()->SetTtl(120);
                        announcement->AppendAnswerL(entry->AddressRecord()->CloneL());
                        iMessageHandler.DnsCache().UpdateCacheL(*(entry->AddressRecord()),ETrue,0);
                        __FLOG(_L8("CMDNSCacheConsistencyMgr::IterateCacheL - 5"));
                        }
					__FLOG(_L8("CMDNSCacheConsistencyMgr::IterateCacheL - 6"));
					iMessageHandler.SendQueryL(announcement,*this);
					__FLOG(_L8("CMDNSCacheConsistencyMgr::IterateCacheL - 7"));
					CleanupStack::Pop();//announcement
					}
				else
				    {
	                if(!entry->IsAuthoritative())
	                    {
	                    DeleteEntry(entry);
	                    //Query(entry);
	                    }				    
				    }
				}
			cacheUpToDate = EFalse;
			}
		delete entry;
		}		
	__FLOG(_L8("CMDNSCacheConsistencyMgr::IterateCacheL - Exit"));	 
	}
	
/*
 * Delete the particular entry from the cache.
 * @param aEntry cacheentry to be delete.
 */	
void CMDNSCacheConsistencyMgr::DeleteEntry(CCacheEntry* aEntry)
	{	
	__FLOG(_L8("CMDNSCacheConsistencyMgr::DeleteEntry - Entry"));
	RBuf8 key;
	//Extract the key & delete
	
	if(aEntry->AddressRecord())
		{
		key.CreateL(GetHostName(aEntry));
		TInt delError = iMessageHandler.DnsCache().DeleteEntryL(key);//TODO: handle error
		}

	key.Close();
	key.CreateL(GetServiceName(aEntry));
	
	TInt error = iMessageHandler.DnsCache().DeleteEntryL(key);
	//Handle error
	key.Close();
	__FLOG(_L8("CMDNSCacheConsistencyMgr::DeleteEntry - Exit"));
	}
	
/*
 * Create a CDnsMessage object to be sent to the network using aEntry.
 *  
 */	
void CMDNSCacheConsistencyMgr::Query(CCacheEntry* aEntry)
	{
	__FLOG(_L8("CMDNSCacheConsistencyMgr::Query - Entry"));
		//Construct DNS Message
	CDnsMessage* message = CDnsMessage::NewL(0,ETrue);
	CleanupStack::PushL(message);

	//Form the Query/Question part of the message
	CDnsQuestion* question = CDnsQuestion::NewL();
	CleanupStack::PushL(question);
	
	question->SetNameL(GetServiceName(aEntry));
	question->SetClass(EDnsClass_IN);
	question->SetType(EDnsQType_Any);

	//Append the Query to the Message
	message->AppendQueryL(question);
	if(aEntry->AddressRecord())
	message->AppendAnswerL(aEntry->AddressRecord()->CloneL());
	
	if(aEntry->ServiceRecord())
	message->AppendAnswerL(aEntry->ServiceRecord()->CloneL());
	
	if(aEntry->TxtRecord())
	message->AppendAnswerL(aEntry->TxtRecord()->CloneL());	
	
	if(aEntry->PtrRecord())
	message->AppendAnswerL(aEntry->PtrRecord()->CloneL());
	
	
		
	//Send the query
	iMessageHandler.SendQueryL(message,*this);		

	CleanupStack::Pop();//question
	CleanupStack::Pop();//message
	__FLOG(_L8("CMDNSCacheConsistencyMgr::Query - Exit"));
	}

/*
 * @return the hostname for the particular record.
 */	
const TDesC8& CMDNSCacheConsistencyMgr::GetHostName(CCacheEntry* aEntry)
	{
	__FLOG(_L8("CMDNSCacheConsistencyMgr::GetHostName - Entry Exit"));
	return aEntry->AddressRecord()->Name();
	}


/*
 * @param aEntry for which service name is required.
 * @return Domain name for the particular service.
 */
const TDesC8& CMDNSCacheConsistencyMgr::GetServiceName(CCacheEntry* aEntry)
	{
	__FLOG(_L8("CMDNSCacheConsistencyMgr::GetServiceName - Entry"));
	if(aEntry->ServiceRecord())
		{
		return aEntry->ServiceRecord()->Name();
		}
	else if (aEntry->TxtRecord())
		{
		return aEntry->TxtRecord()->Name();
		}
	else if(aEntry->PtrRecord())
		{
		return aEntry->PtrRecord()->DomainName();
		}
	else if(aEntry->AddressRecord())
	        {
	        return aEntry->AddressRecord()->Name();
	        }
	
	__FLOG(_L8("CMDNSCacheConsistencyMgr::GetServiceName - Exit"));
	}
	
/*
 * Notified for any queries sent .
 */	
void CMDNSCacheConsistencyMgr::OnPacketSendL(TInt /*aError*/)
	{
	__FLOG(_L8("CMDNSCacheConsistencyMgr::OnPacketSendL - Entry"));
	//Do nothing
	}