// Copyright (c) 2006-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 ESockDebug.TestSteps.cpp
*/

#include <comms-infras/esockdebugmessages.h>

#include "SocketServer.TestSteps.h"
#include "ESockDebug.TestSteps.h"

#include <xml/parser.h>
#include <xml/xmlparsererrors.h>
#include "XmlParsing.h"
#include <elements/sd_mintercept.h>

#include <utf.h>


#ifdef _DEBUG
// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module
// (if it could happen through user error then you should give it an explicit, documented, category + code)
_LIT(KSpecAssert_ESockTestESckDbg, "ESockTestESckDbg");
#endif

using namespace Xml;

// ESOCK Message Intercept Register
//=================================

// Build message intercept pattern
//--------------------------------
CAppendMessageInterceptPattern::CAppendMessageInterceptPattern(CCEsockTestBase*& aEsockTest)
:   CTe_EsockStepBase(aEsockTest)
	{
	SetTestStepName(KAppendMessageInterceptPattern);
	}

TInt CAppendMessageInterceptPattern::ConfigureFromIni()
	{
	// Read in name of socket server used for controlling esock debug
	if((GetStringFromConfig(iSection, KTe_SocketServName, iSocketSvrName) != 1)
		|| (iSocketSvrName.Length() == 0))
		{
		INFO_PRINTF1(_L("Couldn't find appropriate field in config file"));
		return KErrNotFound;
		}

	// We need to have at least one expression
	TInt success;
	TBool done(EFalse);

	// The expressions are indexed from 1 in our config files
	TInt expressionCount = 1;

	// Fetch the action first
	TAction action;
	TRAPD(error, ReadActionL(action));
	if(error != KErrNone)
		{
		INFO_PRINTF1(_L("Couldn't find action field in config file"));
		return KErrNotFound;
		}
	else
		{
		RExpressionList expressionList;
		CleanupClosePushL(expressionList);

		// We have an action so start looking for expressions to go with it
		// One at a time read in whole expressions till no more to be found
		while(!done)
			{
			TEventExpression eventExpression;

			// Read in the expression
			TRAPD(error, ReadEventExpressionL(expressionCount, eventExpression));

			if(error == KErrNone)
				{
				// Found an expression so lets add it to an expression list for this pattern
				expressionList.Append(eventExpression);
				}
			else if(error == KErrNotFound)
				{
				// Must be the end of list of expressions
				done = ETrue;
				}
			else
				{
				// Some kind of xml parsing issue lets get out of here
				CleanupStack::PopAndDestroy(&expressionList);
				return error;
				}

			expressionCount++;
			}

		if(expressionList.Count() > 0)
			{
			iPattern = CPattern::NewL(expressionList, action);
			CleanupStack::Pop(&expressionList);
			success = KErrNone;
			}
		else
			{
			CleanupStack::PopAndDestroy(&expressionList);
			success = KErrArgument;
			}

		}

	return success;
	}

const TInt KConfigSubSectionNameMaxLength = 64;
const TInt KIniDataMaxLength = 256;

void CAppendMessageInterceptPattern::ReadEventExpressionL(TInt aIndex, TEventExpression& aExpression)
	{
	// Fetch the whole ini data subsection that we will parse
	_LIT(KEventSubSectionFormat, "Event%d");
	TBuf<KConfigSubSectionNameMaxLength> subSectionName;
	subSectionName.Format(KEventSubSectionFormat, aIndex);

	TPtrC iniData;
	if(!GetStringFromConfig(iSection, subSectionName, iniData))
		{
		// We must have already found the last event expression
		User::Leave(KErrNotFound);
		}

	// Damn we need to convert the whole ini section back to UTF8
	TBuf8<KIniDataMaxLength> iniData8;
	CnvUtfConverter::ConvertFromUnicodeToUtf8(iniData8, iniData);

	// Add some tags around the outside. XML parser needs them and leaving them out of the ini keeps things simple
	_LIT8(KSurroundingEventTagsFormat, "<Event>%S</Event>");
	TBuf8<KIniDataMaxLength> iniData8tagged;
	iniData8tagged.Format(KSurroundingEventTagsFormat, &iniData8);

	// Its some xml so lets just parse the lot
	CEventExpressionXmlHandler handler(aExpression);
	CParser* parser = CParser::NewLC(KXmlMimeType, handler);
	TRAPD(error, Xml::ParseL(*parser, iniData8tagged));
	if(error != KErrNone)
		{
		INFO_PRINTF2(_L("Error during XML parsing of (%S)."), &subSectionName);
		User::Leave(KErrArgument);
		}

	// Cleanup
	CleanupStack::PopAndDestroy(parser);
	}

void CAppendMessageInterceptPattern::ReadActionL(TAction& aAction)
	{
	// Fetch the whole ini data subsection that we will parse
	TPtrC iniData;
	_LIT(KAction, "Action");
	if(!GetStringFromConfig(iSection, KAction, iniData))
		{
		User::Leave(KErrNotFound);
		}

	// Damn we need to convert the whole ini section back to UTF8
	TBuf8<KIniDataMaxLength> iniData8;
	CnvUtfConverter::ConvertFromUnicodeToUtf8(iniData8, iniData);

	// Its some xml so lets just parse the lot
	CActionXmlHandler handler(aAction);
	CParser* parser = CParser::NewLC(KXmlMimeType, handler);
	TRAPD(error, Xml::ParseL(*parser, iniData8));
	if(error != KErrNone)
		{
		INFO_PRINTF2(_L("Error during XML parsing of (%S)."), KAction);
		User::Leave(KErrNotFound);
		}

	// Cleanup
	CleanupStack::PopAndDestroy(parser);
	}

TVerdict CAppendMessageInterceptPattern::doSingleTestStep()
	{
	SetTestStepResult(EFail);

	// Look up the socket server being used for esock debug control
	RSocketServ* debugSocketServer = iEsockTest->iSockServs.Find(iSocketSvrName);

	if(debugSocketServer)
		{
		// Make the call to reset the ESock debug register with the socket server given
		TRAPD(error, AppendPatternToRegisterL(*debugSocketServer));
		if(error == KErrNone)
			{
			SetTestStepResult(EPass);
			}
		else
			{
			// If it errored then this step failed
			INFO_PRINTF2(_L("Could not enable the ESock message intercept register. Error (%S)."), error);
			}
		}
	else
		{
		INFO_PRINTF1(_L("Could not find socket server for debug control of esock. Error (%S)."));
		}

	return TestStepResult();
	}

CAppendMessageInterceptPattern::~CAppendMessageInterceptPattern()
	{
	delete iPattern;
	}

void CAppendMessageInterceptPattern::AppendPatternToRegisterL(RSocketServ& /*aSocketSvr*/) const
	{
	__ASSERT_DEBUG(iPattern, User::Panic(KSpecAssert_ESockTestESckDbg, 1));
	TUint numExpressions = iPattern->Expressions().Count();
	__ASSERT_DEBUG(numExpressions > 0, User::Panic(KSpecAssert_ESockTestESckDbg, 2));

//TODO MessageIntercept not operational
#if 0
 	// Pull apart the pattern built and send it across to the message intercept register
	TUint index;
	TInt error;
	for(index = 0; index < numExpressions; index++)
		{
		TEventExpression expression = iPattern->Expressions()[index];

		// Build the debug control message for current expression and send it to esock
		TAppendExpressionMsg msg1(expression);
		error = aSocketSvr.__DbgControl(msg1);
		if(error != KErrNone)
			{
			User::Leave(KErrGeneral);
			}
		}

	// And finally terminate the pattern with the action
	TAppendActionMsg msg2(iPattern->Action());
	error = aSocketSvr.__DbgControl(msg2);
	if(error != KErrNone)
		{
		User::Leave(KErrGeneral);
		}
#endif
	User::Leave(KErrGeneral);
	}



// Enable message intercept register
//----------------------------------
CEnableMessageInterceptRegister::CEnableMessageInterceptRegister(CCEsockTestBase*& aEsockTest)
:   CTe_EsockStepBase(aEsockTest), iSocketSvrName(KNullDesC)
	{
	SetTestStepName(KEnableMessageInterceptRegister);
	}

TInt CEnableMessageInterceptRegister::ConfigureFromIni()
	{
	// Read in appropriate fields
	if((GetStringFromConfig(iSection, KTe_SocketServName, iSocketSvrName) != 1)
		|| (iSocketSvrName.Length() == 0))
		{
		INFO_PRINTF1(_L("Couldn't find appropriate field in config file"));
		return KErrNotFound;
		}

	// All ok if we got this far
	return KErrNone;
	}

TVerdict CEnableMessageInterceptRegister::doSingleTestStep()
	{
	SetTestStepResult(EFail);

	// Look up the socket server being used for esock debug control
	RSocketServ* debugSocketServer = iEsockTest->iSockServs.Find(iSocketSvrName);

//TODO MessageIntercept not operational
#if 0
	if(debugSocketServer)
		{
		// Build a debug control message and send it to esock
		MessageIntercept::TEnableMsg msg;
		TInt error = debugSocketServer->__DbgControl(msg);

		if (error != KErrNone)
			{
			// If it errored then this step failed
			INFO_PRINTF2(_L("Could not enable the ESock message intercept register. Error (%S)."), error);
			}
		else
			{
			SetTestStepResult(EPass);
			}
		}
	else
		{
		INFO_PRINTF1(_L("Could not find socket server for debug control of esock. Error (%S)."));
		}
#endif
	return TestStepResult();
	}


// Disable message intercept
//--------------------------
CDisableMessageInterceptRegister::CDisableMessageInterceptRegister(CCEsockTestBase*& aEsockTest)
	: CTe_EsockStepBase(aEsockTest), iSocketSvrName(KNullDesC)
	{
	SetTestStepName(KDisableMessageInterceptRegister);
	}

TInt CDisableMessageInterceptRegister::ConfigureFromIni()
	{
	// Read in appropriate fields
	if((GetStringFromConfig(iSection, KTe_SocketServName, iSocketSvrName) != 1)
		|| (iSocketSvrName.Length() == 0))
		{
		INFO_PRINTF1(_L("Couldn't find appropriate field in config file"));
		return KErrNotFound;
		}

    // All ok if we got this far
    return KErrNone;
	}

TVerdict CDisableMessageInterceptRegister::doSingleTestStep()
	{
	SetTestStepResult(EFail);

	// Look up the socket server being used for esock debug control
	RSocketServ* debugSocketServer = iEsockTest->iSockServs.Find(iSocketSvrName);

	if(debugSocketServer)
		{
		// Build a debug control message and send it to esock
//TODO MessageIntercept not operational
#if 0
		MessageIntercept::TDisableMsg msg;
		TInt error = debugSocketServer->__DbgControl(msg);

		if (error != KErrNone)
			{
			// If it errored then this step failed
			INFO_PRINTF2(_L("Could not disable the ESock message intercept register. Error (%S)."), error);
			}
		else
			{
			SetTestStepResult(EPass);
			}
#endif
		}
	else
		{
		INFO_PRINTF1(_L("Could not find socket server for debug control of esock. Error (%S)."));
		}

	// All ok if we got this far
	return TestStepResult();
	}


// Reset message intercept register
//---------------------------------

CResetMessageInterceptRegister::CResetMessageInterceptRegister(CCEsockTestBase*& aEsockTest)
	: CTe_EsockStepBase(aEsockTest), iSocketSvrName(KNullDesC)
	{
	SetTestStepName(KResetMessageInterceptRegister);
	}

TInt CResetMessageInterceptRegister::ConfigureFromIni()
	{
	// Read in appropriate fields
	if((GetStringFromConfig(iSection, KTe_SocketServName, iSocketSvrName) != 1)
		|| (iSocketSvrName.Length() == 0))
		{
		INFO_PRINTF1(_L("Couldn't find appropriate field in config file"));
		return KErrNotFound;
		}

    // All ok if we got this far
    return KErrNone;
	}

TVerdict CResetMessageInterceptRegister::doSingleTestStep()
	{
    // Default to failing
	SetTestStepResult(EFail);
//TODO MessageIntercept not operational
#if 0
    // Look up the socket server being used for esock debug control
    RSocketServ* debugSocketServer = iEsockTest->iSockServs.Find(iSocketSvrName);

    if(debugSocketServer)
    	{
		// Build a debug control message and send it to esock
		MessageIntercept::TSoftResetMsg msg;
		TInt error = debugSocketServer->__DbgControl(msg);

		if (error != KErrNone)
			{
			// If it errored then this step failed
			INFO_PRINTF2(_L("Could not reset the ESock message intercept register. Error (%S)."), error);
			SetTestStepError(error);
			}
		else
			// Everything ok so we passed
			{
			SetTestStepResult(EPass);
			}
		}
	else
		{
		INFO_PRINTF1(_L("Could not find socket server for debug control of esock. Error (%S)."));
		}
#endif
	return TestStepResult();
	}


// Query completion of message interception
//-----------------------------------------

CQueryMsgInterceptComplete::CQueryMsgInterceptComplete(CCEsockTestBase*& aEsockTest)
	: CTe_EsockStepBase(aEsockTest), iSocketSvrName(KNullDesC)
	{
	SetTestStepName(KQueryMsgInterceptComplete);
	}

TInt CQueryMsgInterceptComplete::ConfigureFromIni()
	{
	// Read in appropriate fields
	if((GetStringFromConfig(iSection, KTe_SocketServName, iSocketSvrName) != 1)
		|| (iSocketSvrName.Length() == 0))
		{
		INFO_PRINTF1(_L("Couldn't find appropriate field in config file"));
		return KErrNotFound;
		}

    // All ok if we got this far
    return KErrNone;
	}

TVerdict CQueryMsgInterceptComplete::doSingleTestStep()
	{
    // Default to failing
	SetTestStepResult(EFail);

    // Look up the socket server being used for esock debug control
    RSocketServ* debugSocketServer = iEsockTest->iSockServs.Find(iSocketSvrName);

//TODO MessageIntercept not operational
#if 0
    if(debugSocketServer)
    	{
		// Build a debug control message and send it to esock
		MessageIntercept::TQueryCompleteMsg msg;
		TInt result = debugSocketServer->__DbgControl(msg);

		if (result < 0)
			{
			// If it errored then this step failed
			INFO_PRINTF2(_L("Could not reset the ESock message intercept register. Error (%S)."), result);
			SetTestStepError(result);
			}
		else if (result == MessageIntercept::EPassedState)
			// Everything ok so we passed
			{
			SetTestStepResult(EPass);
			}
		}
	else
		{
		INFO_PRINTF1(_L("Could not find socket server for debug control of esock. Error (%S)."));
		}
#endif
	return TestStepResult();
	}