// Copyright (c) 2000-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 <watcher.h>
#include <wapmessage.h>

#include "pushwatcher.h"
#include <push/pushlog.h>
#include <push/pushmessage.h>
#include "flogger.h"

#ifdef __WATCHER_API_V2__

#include <ecom/implementationproxy.h>

const TImplementationProxy ImplementationTable[] = 
	{
		IMPLEMENTATION_PROXY_ENTRY(0x10009145, CPushWatcher::NewL)
	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
	{
	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

	return ImplementationTable;
	}
#endif	// __WATCHER_API_V2__

#ifdef __WATCHER_API_V2__
CPushWatcher* CPushWatcher::NewL(TAny* aWatcherParams)
#else
/** single exported constructor to allow creation of push watcher
	which in turn creates Connection Manager and waits for a push
	message to arrive. 
	@param RF
	@param CWatcherLog
	@return pointer to created object
*/
EXPORT_C CPushWatcher* CPushWatcher::NewL(RFs&, CWatcherLog& aLog)
#endif	// __WATCHER_API_V2__
	{
#ifdef __WATCHER_API_V2__
	TWatcherParams* params = reinterpret_cast<TWatcherParams*>(aWatcherParams);
	CPushWatcher* self= new (ELeave) CPushWatcher(CActive::EPriorityStandard, params->iLog);
#else
	CPushWatcher* self = new(ELeave) CPushWatcher(CActive::EPriorityStandard, aLog);
#endif	// __WATCHER_API_V2__
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

/** private constructor */
CPushWatcher::CPushWatcher(TInt aPriority, CWatcherLog& aLog)
: CActive(aPriority), iLog(aLog)
	{
	}

/** destructor to cancel any outstanding requests */
CPushWatcher::~CPushWatcher()
	{
	Cancel();
	}

/** start scheduler and create connection manager, then wait */
void CPushWatcher::ConstructL()
	{
	CActiveScheduler::Add(this);
	iLog.Printf(_L("PushWatcher: Constructing..."));
	iConnMan = CConnectionManager::NewL(*this);
	}

/** watcher starts connection manager and just idles, no other states or
	activities so RunL is empty.

	The Connection Manager processes any push messages. */
void CPushWatcher::RunL()
	{
	// nothing to do
	}

/** no active RunL so no Cancel required */
void CPushWatcher::DoCancel()
	{
	// nothing to do
	}






/** log debug information tp c:\logs\watcher directory if present
	after formatting message to print.
	@param list of args
	@return void 
*/
void CPushWatcher::WPLPrintf(const TDesC& aDescription)
	{
	_LIT(KPushLogFmt,"Push:%S");

	// 7 is the length of "Push:" from above + '\n' tagged on in the Printf()
	TPtrC	buf = aDescription.Left(Min(KWatcherLogBuffer-7, aDescription.Length()));
	iLog.Printf(KPushLogFmt, &buf);
	}

	
/**
 * Takes the data in a Push Message and prints it to console and the logs it to file.
 * Uses the accessor functions of the CPushMessage class and this classes Printf function 
 * to perform this.  Currently 4 headers and the message body are displayed and 
 * logged. The headers are:
 *		PushID, Content-Type, X-Application-ID, Expiry Date, 
 *
 *	@param	CPushMessage& aMessage
 *				in:  a reference to a Push Message.
 */
void CPushWatcher::WPLPrintf(CPushMessage& aMessage)
	{
	TRAPD(error, WPLPrintfL(aMessage));
	if (error != KErrNone)
		{
		_LIT(KErrMessage, "Wap Push Watcher logging failed");
		WPLPrintf(KErrMessage);
		}
	}

/**
 * Private WPLPrint leaving method
 */
void CPushWatcher::WPLPrintfL(CPushMessage& aMessage)
	{
	TBuf<KWatcherLogBuffer> buf;
	
	// Content type
	_LIT(KLogContentFmt,"Content Type : \t%S");
	TPtrC contentPointer;
	aMessage.GetContentType(contentPointer);
	// max length, including the post-append '\n'
	TInt maxSize(KWatcherLogBuffer - (KLogContentFmt().Length()+1));
	TPtrC tmp(contentPointer.Left(maxSize));
	buf.Format(KLogContentFmt,&tmp);
	buf.Append('\n');
	WPLPrintf(buf);

	// Date Field
	_LIT(KLogDateTimeFmt," %-B%:0%J%:1%T%:2%S%+B   %D %N %Y  %4 %5 %3");
	_LIT(KLogDateFmt,"Date           :\tS");
	TBool foundField;
	TTime timeValue;
	foundField = aMessage.GetHeaderField(EHttpDate, timeValue);
	if (foundField)
		{
		timeValue.FormatL(buf, KLogDateTimeFmt);
		buf.Format(KLogDateFmt, &buf);
		WPLPrintf(buf);
		}

	//Expires Field
	foundField = aMessage.GetHeaderField(EHttpExpires, timeValue);
	if (foundField)
		{
		timeValue.FormatL(buf, KLogDateTimeFmt);
		buf.Format(KLogDateFmt, &buf);
		WPLPrintf(buf);
		}

	// X-Wap-Application-ID
	TBool isInt;
	TInt ID;
	TPtrC8 generalPtr;
	_LIT(KLogAppIdIntFmt,"App ID         :\t%X");
	_LIT(KLogAppIdStringFmt,"App ID         :\t%S");
	foundField = aMessage.GetAppIdL(generalPtr, ID, isInt);
	if (foundField) // App ID is present
		{
		if (isInt)  // Field in integer format
			{
			buf.Format(KLogAppIdIntFmt,ID);
			}
		else  // should be descriptor format
			{
			buf.Format(KLogAppIdStringFmt,&generalPtr);
			}
		WPLPrintf(buf);
		}

	//Message Header Binary
	_LIT(KLogMsgHdr,"Header Binary:");
	WPLPrintf(KLogMsgHdr);
	aMessage.GetHeader(generalPtr);
	
	HBufC* tempHdr = HBufC::NewLC(generalPtr.Length());
	tempHdr->Des().Copy(generalPtr);
	WPLLogBinaryAsHex(*tempHdr);
	CleanupStack::PopAndDestroy(); //tempHdr

	//Message Body
	aMessage.GetMessageBody(generalPtr);

	// Dump Body As Text
	_LIT(KLogMsgBody,"Body Text:");
	WPLPrintf(KLogMsgBody);
	HBufC* tempBody = HBufC::NewLC(generalPtr.Length());
	tempBody->Des().Copy(generalPtr);
	WPLPrintf(*tempBody);

	// Dump Body As Hex
	_LIT(KBodyBinary,"Body Binary:");
	WPLPrintf(KBodyBinary);
	WPLLogBinaryAsHex(*tempBody);

	CleanupStack::PopAndDestroy(); //tempBody
	}

 /**
 * Prints out Buffer data in the format:
 *	%X %X %X %X %X %X %X\n etc 
 * For example
 *	AB CD 01 12 34 A2 
 *
 *	@param	aDescription
 *				in:  the descriptor to be dumped into the log
 */
void CPushWatcher::WPLLogBinaryAsHex(const TDesC& aDescription)
	{
	_LIT(KHexSpace,"%02X ");
	TBuf<KWatcherLogBuffer> hexBuf;
	TBuf<KWatcherLogBuffer> buf;

	TInt i = 0, bodyLen = aDescription.Length();

	for (; i < bodyLen; i++)
		{
		hexBuf.Format(KHexSpace,aDescription[i]);
		buf.Append(hexBuf);
		if ( i && ((i+1) % 8) == 0  )
			{
			WPLPrintf(buf);
			buf.Zero();
			}
		}

	if (buf.Length())
		WPLPrintf(buf);
	}



/** log error description to debug file */
void CPushWatcher::WPLLogError(const TDesC& aDescription,TInt aError)
	{
	_LIT(KErrorLogFmt,"Push:%S, Error\t%d");
	const TInt KWatcherLogBuffer=256;
	TBuf<KWatcherLogBuffer> buf;
	buf.Format(KErrorLogFmt,&aDescription,aError);
  	buf.Append('\n');
	WPLPrintf(buf);
	}