// Copyright (c) 1997-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
 @internalTechnology
*/

#include "EventLogger.h"
#include "SLogger.h"
#include "AgentPanic.h"
#include <logengdurations.h>

EXPORT_C CEventLogger* CEventLogger::NewL()
	{
	CEventLogger* eventLogger = new(ELeave) CEventLogger;
	CleanupStack::PushL(eventLogger);
	eventLogger->ConstructL();
	CleanupStack::Pop();
	return eventLogger;
	}

CEventLogger::CEventLogger(): CActive(EPriorityIdle)
	{
	CActiveScheduler::Add(this);
	}

void CEventLogger::ConstructL()
	{
	User::LeaveIfError(iFsEventLog.Connect());
	iLogWrap = CLogWrapper::NewL(iFsEventLog,CActive::EPriorityStandard);
	iCurrentLogEvent = CLogEvent::NewL();
	iLogEventQueue = new(ELeave) CArrayPtrFlat<CLogEvent>(KEventStateMaxCount);
	}

EXPORT_C CEventLogger::~CEventLogger()
	{
	Cancel();
	// the queue could be not empty if the active object is aborted and destructed
	while (iLogEventQueue && (iLogEventQueue->Count() > 0))
		{
		CLogEvent* eventPtr = iLogEventQueue->At(0);
		// delete the CLogEvent object
		delete eventPtr;
		//remove the pointer from the queue
		iLogEventQueue->Delete(0);
		}
	delete iLogWrap;
	iLogWrap=NULL;
	delete iCurrentLogEvent;
	iCurrentLogEvent=NULL;
	delete iLogEventQueue;
	iLogEventQueue = NULL;
	iFsEventLog.Close();
	}

EXPORT_C void CEventLogger::Cancel()
	{
	if(iLogWrap)
		{
		iLogWrap->Log().Cancel();
		}
	//this method written before CEventLogger moved to a CActive is hiding the access to Cactive version of Cancel()
	// The only time cancel should be called is when there is a Panic and we need to destroy the whole object)
	CActive::Cancel();
	}

EXPORT_C void CEventLogger::LogCallStart(const TDesC& aRemote,TInt aLogDir,const TDesC& aTelNum,TUid aDataEventType, TRequestStatus& aStatus)
/**
DEPRECATED, use LogDataAddEvent instead
*/
	{
	LOGSTRING2("GenConn:\tCEventLogger LogCallStart aRemote:%S", &aRemote);
	LogDataAddEvent(R_LOG_CON_CONNECTED, aRemote, aLogDir, aTelNum, aDataEventType);
	// we could complete the TRequestStatus right now. We go safer way and let istatus complete when logg evnt has been added
	LogDataNotifyLastEventUpdate(&aStatus);
	}

EXPORT_C void CEventLogger::LogCallEnd(TRequestStatus& aStatus)
/**
DEPRECATED, use  LogDataUpdateEvent instead
some code may rely on aStatus being triggered when the logger has completed doing 
the last update so that we destroy everything
*/
	{
	LOGSTRING("GenConn:\tCEventLogger LogCallEnd");
	LogDataUpdateEvent( R_LOG_CON_DISCONNECTED, TUid::Null());
	LogDataNotifyLastEventUpdate(&aStatus);	
	}

EXPORT_C void CEventLogger::LogDataTransferred(TInt64 aBytesSent, TInt64 aBytesReceived,TUid aDataEventType, TRequestStatus& aStatus)
/**
DEPRECATED, use  LogDataUpdateEvent instead
*/
	{
	LogDataUpdateEvent(KConnectionStatusIdNotAvailable , aDataEventType, aBytesSent, aBytesReceived);
	// we complete the aStatus right now even if the log might be updated later
	TRequestStatus* st = &aStatus;
	User::RequestComplete(st, KErrNone);
	}
EXPORT_C void CEventLogger::LogDataAddEvent(TInt aRConnectionStatusId, const TDesC& aRemote, TInt aLogDir, const TDesC& aTelNum, TUid aDataEventType)
	{
	LOGSTRING2("GenConn:\tCEventLogger LogDataAddEvent aRConnectionStatusId:%d", aRConnectionStatusId);
	//It is possible to add a new logevent with a new log id for the same connection (reconnect case)
	// assuming that all the next updates will be for the new event and not the old one.

	// [NeilMa 140403]: This method cannot leave and has no return value, but 
	// performs memory allocations if the event cannot be logged immediately. 
	// Therefore, if the memory alloc fails for any reason, the event is 
	// currently discarded with no record. This method should be replaced by 
	// one which can Leave or returns an error code. See Typhoon DEF022946.
	TTime time;
	time.UniversalTime();

	if (!IsActive() && (iLogEventQueue->Count() ==0))
		{
	    iCurrentLogEvent->SetId(KGenconnLogWaitingForLogId);
		iCurrentLogEvent->SetTime(time);
		TBuf<KLogMaxStatusLength > logStatusBuf;
		iLogWrap->Log().GetString(logStatusBuf, aRConnectionStatusId); // Ignore error - string blank on error which is ok
		iCurrentLogEvent->SetStatus(logStatusBuf);
		iCurrentLogEvent->SetRemoteParty(aRemote);
		TBuf<KLogMaxDirectionLength> logDirBuf;
		iLogWrap->Log().GetString(logDirBuf, aLogDir); // Ignore error - string blank on error which is ok
		iCurrentLogEvent->SetDirection(logDirBuf);
		iCurrentLogEvent->SetNumber(aTelNum);
		iCurrentLogEvent->SetEventType(aDataEventType);
		iCurrentLogEvent->SetDurationType(KLogDurationValid);
		iStatus=KRequestPending;
		iLogWrap->Log().AddEvent(*iCurrentLogEvent, iStatus);
		SetActive();
		}
	else
		{
		// add the request to the queue, it will be processed asap
		CLogEvent* eventUpdate = 0;
		TRAPD(error, eventUpdate = CLogEvent::NewL());
		if (KErrNone != error)
			{
			return; // event is discarded!
			}
	    eventUpdate->SetId(KGenconnLogWaitingForLogId);
		eventUpdate->SetTime(time);
		TBuf<KLogMaxStatusLength > logStatusBuf;
		iLogWrap->Log().GetString(logStatusBuf, aRConnectionStatusId); // Ignore error - string blank on error which is ok
		eventUpdate->SetStatus(logStatusBuf);
		eventUpdate->SetRemoteParty(aRemote);
		TBuf<KLogMaxDirectionLength> logDirBuf;
		iLogWrap->Log().GetString(logDirBuf, aLogDir); // Ignore error - string blank on error which is ok
		eventUpdate->SetDirection(logDirBuf);
		eventUpdate->SetNumber(aTelNum);
		eventUpdate->SetEventType(aDataEventType);
		eventUpdate->SetDurationType(KLogDurationValid);
		// add to the queue
		TRAP(error, iLogEventQueue->AppendL(eventUpdate));
		if (KErrNone != error)
			{
			delete eventUpdate; // event is discarded!
			return;
			}
		}
	}

TInt CEventLogger::UpdateLogEventParam(CLogEvent& aLogEvent, TInt aRConnectionStatusId, const TUid& aDataEventType, const TInt64& aBytesSent, const TInt64& aBytesReceived)
	{
	
	TTime time;
	TInt ret =KErrNone;
	time.UniversalTime();
	TTimeIntervalSeconds interval(0);
	if (time.SecondsFrom(iCurrentLogEvent->Time(),interval) != KErrNone)
		{
		interval = 0;	// no duration available ->error
		}
	if (KConnectionStatusIdNotAvailable != aRConnectionStatusId)
		{
		//status needs to be updated
		TBuf<KLogMaxStatusLength > logStatusBuf;
		iLogWrap->Log().GetString(logStatusBuf, aRConnectionStatusId); // Ignore error - string blank on error which is ok
		aLogEvent.SetStatus(logStatusBuf);
		}
	if ( aDataEventType != TUid::Null())
		{
		aLogEvent.SetEventType(aDataEventType);
		}
	aLogEvent.SetDuration(interval.Int());		//0 or not
	//check if data metrics need to be updated
	TInt64 byteInfoNotAvailable(KBytesInfoNotAvailable);
	if ((aBytesReceived != byteInfoNotAvailable) && (aBytesSent != byteInfoNotAvailable))
		{
		TBuf8<KDatabufferSize> dataBuffer;
		dataBuffer.Num(aBytesSent);
		dataBuffer.Append(TChar(','));
		dataBuffer.AppendNum(aBytesReceived);
		TRAP(ret, aLogEvent.SetDataL(dataBuffer));
		}
	return ret;
	}
EXPORT_C TInt CEventLogger::LogDataUpdateEvent(TInt aRConnectionStatusId, const TUid& aDataEventType)
	{
	return LogDataUpdateEvent(aRConnectionStatusId, aDataEventType, KBytesInfoNotAvailable, KBytesInfoNotAvailable);
	}

EXPORT_C TInt CEventLogger::LogDataUpdateEvent(TInt aRConnectionStatusId, const TUid& aDataEventType, const TInt64& aBytesSent, const TInt64& aBytesReceived)
	{
	LOGSTRING("GenConn:\tCEventLogger LogDataUpdateEvent");
	TInt ret = KErrNone;
	// check if there is a request ongoing on the current event
	// check if no request pending then start it otherwise wait until the previous request is finished and keep going on.
	//PROBLEM HERE: 
	// if LogDataAddEvent has not been called then iCurrentLogEvent->Id() == KLogNullId we do nothing, we should assert
	// if id is not ready yet, iCurrentLogEvent->Id() is equal to KGenconnLogWaitingForLogId and the active object is active.
	// So it is put as a request and it will be updated when the event is ready to be processed otherwise if we don't log at all, we should do nothing.
	if (iCurrentLogEvent->Id() != KLogNullId)
		{
		if (!IsActive() && (iLogEventQueue->Count() ==0))
			{
			// request update straight on
			UpdateLogEventParam(*iCurrentLogEvent, aRConnectionStatusId, aDataEventType, aBytesSent, aBytesReceived);
			iLogWrap->Log().ChangeEvent(*iCurrentLogEvent, iStatus);
			SetActive();
			}
		else
			{
			// add the request to the queue, it will be processed asap
			CLogEvent* eventUpdate = 0;
			TRAP(ret, eventUpdate = CLogEvent::NewL());
			if(KErrNone != ret)
				{
				return ret;
				}
			TRAP(ret, eventUpdate->CopyL(*iCurrentLogEvent));
			if(KErrNone != ret)
				{
				delete eventUpdate;
				return ret;
				}

			ret = UpdateLogEventParam(*eventUpdate, aRConnectionStatusId, aDataEventType, aBytesSent, aBytesReceived);
			if(KErrNone != ret)
				{
				delete eventUpdate;
				return ret;
				}

			// add to the queue
			TRAP(ret, iLogEventQueue->AppendL(eventUpdate));
			if(KErrNone != ret)
				{
				delete eventUpdate;
				return ret;
				}
			}
		}
	return ret;
	}

EXPORT_C void CEventLogger::LogDataNotifyLastEventUpdate(TRequestStatus* aStatus)
	{
	//only 1 listener for the notification supported
	__ASSERT_DEBUG((iNotificationRequestStatus == NULL), AgentPanic(Agent::EEventLoggerMoreThanOneListenerForNotifyLastUpdate));
	iNotificationRequestStatus = aStatus;
	if (!IsActive() && (iLogEventQueue->Count() ==0))
		{
		//already finished processing all the log event updates in the queue
		// we can complete straight on
		User::RequestComplete(iNotificationRequestStatus, KErrNone);
		iNotificationRequestStatus = NULL;	// did the job, so do need the pointer anymore.
		}
	}

void CEventLogger::RunL()
	{
	// request has completed
	// delete completed event and check if there is a next event pending
	// If LogEng is not supported, a dummy logeng just returns error straight on.
	// but we carry on doing all the requests
	if (iLogEventQueue->Count() >0)
		{
		CLogEvent* nextEventPtr = iLogEventQueue->At(0);
		__ASSERT_DEBUG((nextEventPtr != NULL), AgentPanic(Agent::ENullCLogEventPointerPresentInLogEventQueue));
		if (nextEventPtr->Id() == KGenconnLogWaitingForLogId)
			{
			//Id was not available when the update has been entered because addEvent did not return at that time
			nextEventPtr->SetId(iCurrentLogEvent->Id());
			}
		iCurrentLogEvent->CopyL(*nextEventPtr);
		iLogWrap->Log().ChangeEvent(*iCurrentLogEvent, iStatus);
		SetActive();
		// delete the ongoing CLogEvent we just copied to currentLogEvent
		delete nextEventPtr;
		//remove the pointer from the queue
		iLogEventQueue->Delete(0);
		}
	else if (iNotificationRequestStatus!=NULL)
		{
		// We have finished processing all the log event updates in the queue
		User::RequestComplete(iNotificationRequestStatus, KErrNone);
		iNotificationRequestStatus = NULL;	// did the job, so do need the pointer anymore.
		}
	}

void CEventLogger::DoCancel()
	{
	if(iLogWrap)
		{
		iLogWrap->Log().Cancel();
		}
	// usually you do not need to cancel an update on events, just let them go and be removed from the queue when update is done
	// if we cancel the logger, most likely the whole Logger Object will be destroyed
}