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

#include "f32file.h" 

#include "cmessagehandler.h"
#include "csendmessagequeue.h"
__FLOG_STMT(_LIT8(KComponent,"MDNSServer");)
/**
Two phase constructor
@param aDnsMessage Dns message to be sent 
@param aUnicast True if it is a unicast response
@param aAddr address to which the packet to be send
@return CSendMessageData object
*/
CSendMessageData* CSendMessageData::NewL(CDnsMessage* aDnsMessage, TBool aUnicast,TSockAddr aAddr,MMessageHandler& aCallback)
	{
	CSendMessageData* self = new(ELeave)CSendMessageData(aDnsMessage,aUnicast,aAddr,aCallback);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;	
	}

/**
Constant function which returns the reference to the Dns message object it wraps
@return constant reference to dnsmessage object
*/
const CDnsMessage& CSendMessageData::GetDnsMessage()const
	{
	__FLOG(_L8("CSendMessageData::GetDnsMessage - Exit"));
	return const_cast<CDnsMessage&> (*iMessage);	
	}

/**
Constant function which returns the address of the data to be sent
@return Constant reference to the address
*/
const TSockAddr& CSendMessageData::GetSockAddress()const
	{
	__FLOG(_L8("CSendMessageData::GetSockAddress - Exit"));
	return iSockAddr;	
	}

/**
Constant function which returns true if the message is unicast
@return True if message is unicast
*/
const TBool& CSendMessageData::IsUnicast()const
	{
	__FLOG(_L8("CSendMessageData::IsUnicast - Exit"));
	return iUnicast;	
	}
/**
Destructor
*/
CSendMessageData::~CSendMessageData()
	{
	__FLOG(_L8("CSendMessageData::~CSendMessageData - Entry"));
	delete iMessage;
	__FLOG(_L8("CSendMessageData::~CSendMessageData - Exit"));
	__FLOG_CLOSE;
	}

/**
Two phase constructor
@param aDnsMessage DnsMessage to be send
*/
void CSendMessageData::ConstructL()
	{
	__FLOG_OPEN(KMDNSSubsystem, KComponent);	
	}
	
/**
Constructor
@param aUnicast True if it is a unicast response
@param aAddr Address to which the data to be sent
*/
CSendMessageData::CSendMessageData(CDnsMessage* aDnsMessage,TBool aUnicast,TSockAddr aAddr,MMessageHandler& aCallback):iMessage(aDnsMessage),iUnicast(aUnicast),iSockAddr(aAddr),iCallback(aCallback)
	{
	
	}

MMessageHandler& CSendMessageData::Callback()
	{
	__FLOG(_L8("CSendMessageData::Callback - Exit"));
	return iCallback;	
	}
/**
Two phase Constructor
@param aSocket reference to the RSocket
*/
CSendMessageQueue* CSendMessageQueue::NewL(RSocket& aSocket)
	{
	CSendMessageQueue* self = new (ELeave)CSendMessageQueue();
	CleanupStack::PushL(self);
	self->ConstructL(aSocket);
	CleanupStack::Pop(self);
	return self;		
	}
	
/**
Constructor
*/
CSendMessageQueue::CSendMessageQueue():CTimer(EPriorityStandard)
	{
	CActiveScheduler::Add(this);	
	}
	
/**
Function derived from MSocketHandler Observer.
This method will be called on succesfull sending of the packet.
*/
void CSendMessageQueue::OnCompletionL(TDesC8& /*aData*/, const TSockAddr& /*aAddr*/, TInt /*aLength*/)
	{
	__FLOG(_L8("CSendMessageQueue::OnCompletionL - Entry"));
	if(iSendMessageData)
		{
		iIsSocketActive = EFalse;
		iSendMessageData->Callback().OnPacketSendL(KErrNone);	
		}
	delete iSendMessageData;
	iSendMessageData = NULL;
	if(iMessageQueue.Count() > 0 && !IsActive() )
		{
		StartTransmit();
		}
	__FLOG(_L8("CSendMessageQueue::OnCompletionL - Exit"));
	}

/*
Function derived from MSocketHandler Observer.
This method will be called on error in  sending the packet.
*/	
void CSendMessageQueue::OnError(TInt aError)
	{
	__FLOG(_L8("CSendMessageQueue::OnError - Entry"));
	if(iSendMessageData)
		{
		iSendMessageData->Callback().OnPacketSendL(aError);	
		}	
	__FLOG(_L8("CSendMessageQueue::OnError - Exit"));
	}
	
/**
Destructor
*/	
CSendMessageQueue::~CSendMessageQueue()
	{
	__FLOG(_L8("CSendMessageQueue::~CSendMessageQueue - Entry"));
	delete iSendSocket;
	delete iSendMessageData;
	iMessageQueue.ResetAndDestroy();
	iMessageQueue.Close();	
	iOutput.Close();
	__FLOG(_L8("CSendMessageQueue::~CSendMessageQueue - Exit"));
	__FLOG_CLOSE;
	}

/**
Two phase constructor
@param refernce to RSocket
*/	
void CSendMessageQueue::ConstructL(RSocket& aSocket)
	{
	__FLOG(_L8("CSendMessageQueue::ConstructL - Entry"));
	iSendSocket = CSocketHandler::NewL(aSocket, *this, ESocketSend);
	CTimer::ConstructL();
	iIsSocketActive = EFalse;
	__FLOG(_L8("CSendMessageQueue::ConstructL - Exit"));
	}
	
/**
Derived from CActive
*/	
void CSendMessageQueue::RunL()
	{
	__FLOG(_L8("CSendMessageQueue::RunL - Entry"));
	if (MessageReady())
		{
		iSendMessageData = NextDnsMessageL();
		CleanupStack::PushL(iSendMessageData);
		const CDnsMessage& dnsMessage = iSendMessageData->GetDnsMessage();
		// close the previously allocated memory.  
		iOutput.Close();
		//composes the message from the Dnsmessage object .
		CDnsMessageComposerParser* comPos = CDnsMessageComposerParser::NewL();
		CleanupStack::PushL(comPos);
		comPos->CreateMessageL(iOutput, iSendMessageData->GetDnsMessage());
		TSocketHandlerParams param(ESocketSendTo,&iOutput,&(iSendMessageData->GetSockAddress()));
		iSendSocket->Activate(param);
		iIsSocketActive = ETrue;
		CleanupStack::PopAndDestroy();//comPos
		CleanupStack::Pop();
		}
	__FLOG(_L8("CSendMessageQueue::RunL - Exit"));
	}
/*
 * Nothing to do.
 */
void CSendMessageQueue::DoCancel()
	{
	__FLOG(_L8("CSendMessageQueue::DoCancel - Exit"));
	}

void CSendMessageQueue::QueueDnsMessageL(const CSendMessageData& aMessageData)
	{
	__FLOG(_L8("CSendMessageQueue::QueueDnsMessageL - Entry"));
	if (aMessageData.IsUnicast())
		{
		// Unicast replies are to be given higher priority .
		// Insert the  unicast response in the queue.
		TInt count(iMessageQueue.Count());
		TInt index(0);
		for (; index < count; ++index)
			{
			if (!iMessageQueue[index]->IsUnicast())
				{
				break;
				}
			}
		iMessageQueue.InsertL(&aMessageData, index);
		
		iNextTransmit.HomeTime();
		Cancel();
		}
	else
		{
		// Queue the packet
		iMessageQueue.AppendL(&aMessageData);
		}
	
	// kick the transmit limiter, so we're sure the message will be sent
	if(!iIsSocketActive)
	    {
	    NextTransmitTime(iNextTransmit);
	    }
	__FLOG(_L8("CSendMessageQueue::QueueDnsMessageL - Exit"));	
	}
	
void CSendMessageQueue::NextTransmitTime(TTime aTime)
	{
	__FLOG(_L8("CSendMessageQueue::NextTransmitTime - Entry"));
	// if we aren't already active, set the next TX time
	if (!IsActive())
		{
		TTime now;
		now.HomeTime();
		
		if (aTime > now)
			{
			At(aTime);
			}
		else
			{
			StartTransmit();
			}
		}	
	__FLOG(_L8("CSendMessageQueue::NextTransmitTime - Exit"));
	}

void CSendMessageQueue::StartTransmit()
	{
	__FLOG(_L8("CSendMessageQueue::StartTransmit - Entry"));
	SetActive();
	TRequestStatus *status = &iStatus;
	User::RequestComplete(status,KErrNone);
	__FLOG(_L8("CSendMessageQueue::StartTransmit - Exit"));
	}

CSendMessageData* CSendMessageQueue::NextDnsMessageL()
	{
	__FLOG(_L8("CSendMessageQueue::NextDnsMessageL - Entry"));
	if (0 == iMessageQueue.Count())
		{
		User::Leave(KErrNotReady);
		}
		
	CSendMessageData* ret = iMessageQueue[0];
	iMessageQueue.Remove(0);
	// calculate the next possible transmit time.
	iNextTransmit.HomeTime();
	TInt delay = 20 + (Math::Rand(iRandomSeed) % 100);
	iNextTransmit += TTimeIntervalMicroSeconds(delay * 1000);  
	__FLOG(_L8("CSendMessageQueue::NextDnsMessageL - Exit"));
	return ret;
	}

TBool CSendMessageQueue::MessageReady()
	{
	__FLOG(_L8("CSendMessageQueue::MessageReady - Entry"));
	TBool ready = EFalse;
	if (0 != iMessageQueue.Count())
		{
		if (iMessageQueue[0]->IsUnicast())
			{
			// unicast messages go out straight away.
			ready = ETrue;
			}
		else
		 	{
		 	TTime now;
		 	now.HomeTime();
		 	if (!IsActive())
		 		{
		 		if (now >= iNextTransmit)
		 			{
		 			ready = ETrue;
		 			}
		 		else
		 			{
					NextTransmitTime(iNextTransmit);		 		
		 			}
		 		}
			}
		}
	__FLOG(_L8("CSendMessageQueue::MessageReady - Exit"));
	return ready;
	}