// Copyright (c) 2002-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:
// $Header$
// This module implements the collection of HTTP Framework related integration
// test commands and tools
// by:		mjdavey, symbian@mjdss.com, August 2002
// for:	Typhoon (7.0s) & JetStream (8.0)
// Include Files  
// 
//


#include "CHTTPFamily.h"
#include "HttpSessionCmds.h"
#include "HttpFrmwrk.h"
#include "CWspEventDispatcher.h"

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//	Command:	CONNECT command.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
//	Form:
//				CONNECT <framework> <connection name>
//	Example:	
//				CONNECT HTTP framework1
//
//	The connection made is assigned the name <connection name> e.g. 'framework1'
//	and is referenced by subsequent tagname replacement.
//	the connection session is then associated with this tagname and can be 
//	used until the corresponding DISCONNECT <connection name> is encountered.
//	The 'Engine' has an arbitrary collection object that is used to maintain these 
//	links

CCmdConnect *CCmdConnect::NewL(TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)
	{
	CCmdConnect *self = NewLC( aCommandId, aKeyphrase, aHelpPhrase);
	CleanupStack::Pop();
	return self; 
	}

//-----------------------------------------------------------------------------

CCmdConnect *CCmdConnect::NewLC( TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)
	{
	CCmdConnect *self = new (ELeave) CCmdConnect();
	CleanupStack::PushL(self);
	self->ConstructL(aCommandId, aKeyphrase, aHelpPhrase);
	return self;
	}

//-----------------------------------------------------------------------------

void CCmdConnect::ConstructL(TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)
	{
	CCmdBase::ConstructL(aCommandId, aKeyphrase, aHelpPhrase);

	//	create the Active Object interface
	iEventDispatcher = CWspEventDispatcher::NewL(*this);  

	WaitForNextEvent (THTTPSessionEvent::EDisconnected);

	}

//-----------------------------------------------------------------------------

CCmdConnect::~CCmdConnect(void)
	{
	iEventDispatcher->CancelWait();

	delete iEventDispatcher;
	// void WaitForNextEvent(TInt);
	}

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

void CCmdConnect::DisconnectL(const TDesC& aLabel)
	{
	CAnyObject *obj = (CAnyObject *)Machine()->Domains()->Name(aLabel);
	CFrmwrkSession *frmwk = (CFrmwrkSession *) obj->Ptr();
	TPtrC myName = frmwk->Name() ;
	
	
	Log(_L("CCmdConnect::DisconnectL, Session %S"), &myName);
	frmwk->DisconnectL();
	}

void CCmdConnect::DisconnectL(const TInt &aIndex)
	{
	CAnyObject *obj = (CAnyObject *)Machine()->Domains()->At(aIndex);
	CFrmwrkSession *frmwk = (CFrmwrkSession *) obj->Ptr();
	TPtrC myName = frmwk->Name() ;
	
	
	Log(_L("CCmdConnect::DisconnectL, Session %S"), &myName);
	frmwk->DisconnectL();
	}

void CCmdConnect::Delete(const TDesC& aLabel)
	{
	CAnyObject *obj = (CAnyObject *)Machine()->Domains()->Name(aLabel);
	CFrmwrkSession *frmwk = (CFrmwrkSession *) obj->Ptr();
	TPtrC myName = frmwk->Name() ;

	Log(_L("CCmdConnect::Delete, Session %S"), &myName);
	frmwk->Close(); 
	delete frmwk;
	}

TInt CCmdConnect::ProcessL( const TDesC& aCommand )
{
	// Complete the test machine - will then get the next cmd
	Machine()->CompleteRequest();

	TPtrC framework;
	TPtrC conname;

	TInt error;
	if (( error = ParseCmdArgs( aCommand, framework, conname )) != KErrNone)
		return error;
	
	if (conname.Size() != 0)
		{		
		//	Check if the connection already is defined. 
		//	If it is return error, if not create a session and ptr!
		CAnyObject *cnx = (CAnyObject *)Machine()->Domains()->Name(conname);
	
		if (cnx != NULL)		//	already exists
			return Error(KErrAlreadyExists, THA_KErrCnxionExists, &conname);
		else
			{
			CFrmwrkSession *cithc = CFrmwrkSession::NewLC(conname, framework, Machine());
			cithc->iEventDispatcher = iEventDispatcher ;

			TRAPD(error, cithc->OpenL());
			if (error == KErrNone)
				{
				cithc->SetPropertiesL();
			
				TRAP(error, cithc->ConnectL());
				
				if (error == KErrNone)
					{
					//	now create reference to name in domains
					//	note: the value is 1 for HTTP and 0 for WSP
					Machine()->Domains()->AddL(conname, 0, THA_KHTTP_Connect, (TAny *) cithc);
					WriteDateStamp();
					Log(_L("Connection '%S' has been opened!"), &conname);
					}
				else
					Error(error, KTxtErrConnectFailed);
				}
			
			CleanupStack::Pop();	// cithc
			}
		}
	else
		{		
		(void) ShowSessions () ;
		}

	return error;
}

TInt CCmdConnect::ParseCmdArgs( const TDesC& aCommand, TPtrC& aFramework, TPtrC& aConName ) 
	{
	aFramework.Set(NULL, 0);
	aConName.Set(NULL, 0);
	TInt error = KErrNone;

	//	get the command into a local string
	TPtrC param;
	TRAP(error, param.Set(ParamsL(aCommand)));
	if (error != KErrNone)
		return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

	//	check its' valid
	TLex parse(param);
	if (!parse.Eos() && !parse.Peek().IsSpace())
		return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

	//	remove any spaces and see if its got params
	parse.SkipSpace();
	if ( parse.Eos() )	// no params
		return error;
	
	//	Get framework name, must not exceed 16 characters.
	//	should be http or wsp (currently)

	TRAP(error, aFramework.Set(TfrLex::GetL(parse)));
	if ( error != KErrNone) 
		return Error(KErrArgument, TFR_KFmtErrBadCmd, &aFramework);

	//	check is valid length
	aFramework.Set(TfrLex::Peel(aFramework));
	if ( aFramework.Length() > 16 ) 
		return Error(KErrArgument, THA_KErrParameterLong, &aFramework);

	//	check aFramework type valid (HTTP or WSP)
	//	Param shall be HTTP (True) or WSP (False)
	aFramework.Set( TfrLex::TrimAndPeel(aFramework) );
	TBool value = (aFramework.CompareF(THA_KTxtFrameworkHTTP) == 0);
	
	if ( !value && (aFramework.CompareF(THA_KTxtFrameworkWSP) != 0))
		return Error(KErrArgument, THA_KErrFrameworkErr, &aFramework);

	// Get connection/session name value.

	TRAP(error,aConName.Set(TfrLex::GetL(parse)));
	if ( error != KErrNone) 
		return Error(KErrArgument, TFR_KFmtErrBadCmd, &aConName);

	// There shall not be anything more.
	TPtrC remainder = TfrLex::Trim(parse.Remainder());
	if ( remainder.Length() > 0 ) 
		return Error(KErrArgument, TFR_KFmtErrBadCmd, &remainder);

	if (aConName.Length() <= 0)
		return Error(KErrArgument, THA_KErrInvalidConnect, &Keyphrase());

	aConName.Set(TfrLex::Peel(aConName));
	return (KErrNone);
	}

void CCmdConnect::ShowSessions ()
	{
	
	CObjCatalogue *cnxns = Machine()->Domains();
	TInt iCnxns = 0;
	if (cnxns->Count() == 0)
		Log(_L("\tNo connections have been defined"));
	else
		{
		Log(_L("\t   Name   Framework"));
		for (TInt i = 0; i < cnxns->Count(); ++i)
			{
			CAnyObject *obj = (CAnyObject *)cnxns->At(i);
			if (obj->Tag() == THA_KHTTP_Connect)
				{
				TPtrC label = obj->Name();
				TPtrC frmwrk = ((TBool) ((CFrmwrkSession *) obj->Ptr())->UseWSPProtocol()) ? _L("WSP") : _L("HTTP");
				++iCnxns;
				Log(_L("\t%d %S  - %S"), iCnxns, &label, &frmwrk);
				}
			}
		}
	}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//	Command:	DISCONNECT command.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
//	Form:
//				DISCONNECT <connection name>
//	Example:	
//				DISCONNECT framework1
//

CCmdDisconnect *CCmdDisconnect::NewL(TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)
	{
	CCmdDisconnect *self = NewLC( aCommandId, aKeyphrase, aHelpPhrase);
	CleanupStack::Pop();
	return self; 
	}

//-----------------------------------------------------------------------------

CCmdDisconnect *CCmdDisconnect::NewLC( TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)
	{
	CCmdDisconnect *self = new (ELeave) CCmdDisconnect();
	CleanupStack::PushL(self);
	self->ConstructL(aCommandId, aKeyphrase, aHelpPhrase);
	return self;
	}

//-----------------------------------------------------------------------------

void CCmdDisconnect::ConstructL( TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)
	{
	CCmdBase::ConstructL(aCommandId, aKeyphrase, aHelpPhrase);
	}

//-----------------------------------------------------------------------------

CCmdDisconnect::~CCmdDisconnect(void) 
	{
	}

TInt CCmdDisconnect::ParseCmdArgs( const TDesC& aCommand, TPtrC& aConName ) 
	{
	aConName.Set(NULL, 0);

	//	get the command into a local string
	TPtrC param;
	TRAPD(error, param.Set(ParamsL(aCommand)));
	if (error != KErrNone)
		return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

	//	check its' valid
	TLex parse(param);
	if (!parse.Eos() && !parse.Peek().IsSpace())
		return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

	//	remove any spaces and see if its got params
	parse.SkipSpace();
	if (parse.Eos() ) 
		// If no params return error
		return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

	// Get connection/session name value.
	TRAP(error,aConName.Set(TfrLex::GetL(parse)));
	if (error != KErrNone) 
		return Error(KErrArgument, TFR_KFmtErrBadCmd, &Keyphrase());

	// There shall not be anything more.
	TPtrC remainder = TfrLex::Trim(parse.Remainder());
	if (remainder.Length() > 0) 
		return Error(KErrArgument, TFR_KFmtErrBadCmd, &Keyphrase());

	if (aConName.Length() <= 0)
		return Error(KErrArgument, THA_KErrInvalidConnect, &aConName);

	aConName.Set(TfrLex::Peel(aConName));
	return (KErrNone);
	}

TInt CCmdDisconnect::ProcessL(const TDesC& aCommand)
	{
	// Complete the test machine - will then get the next cmd
	Machine()->CompleteRequest();

	TInt error;
	TPtrC conname;
	if (( error = ParseCmdArgs( aCommand, conname )) != KErrNone)
		return error;

	//	Check if the connection already is defined. 
	//	If it is return error, if not create a session and ptr!
	CAnyObject *obj = (CAnyObject *) Machine()->Domains()->Name(conname);

	// at this point we can find the session that the disconnect refers to
	// in the Session, save disconnects eventhandler.
		
	if (obj != NULL)	//	connection (name) exists
		{
		//	get reference to list in CmdConnect from Family and retrieve the reference to the session
		CCmdConnect *iConnect = (CCmdConnect *)Family()->Command(THA_KHTTP_Connect);

		iConnect->DisconnectL(conname);
	
		TBool frmwrk = ((CFrmwrkSession *) obj->Ptr())->UseWSPProtocol() ;

		if (!frmwrk)		// HTTP Session so complete request
			{
			//	check that there are no existing transactions (live) for this session
			//	and that the session is not already closed (i.e. in error)

			//XXXXXXX

			iConnect->Delete(conname); 
			Machine()->Domains()->Delete(conname);

			//	what about the iSessionIndex - this is going to be problematic since we need to track the 
			//	index into the session when it changes...
			WriteDateStamp();
			Log(_L("\tConnection '%S' has been disconnected!"), &conname);
			}
		else
			{
			Log(_L("Issued DisconnectL"));
			}
		}
	else
		return Error(KErrNotFound, THA_KErrConnectionErr, &conname);
	
	if ( error != KErrNone )
		Log(TFR_KFmtErrFailed, &Keyphrase(), error);

	return error;
}

void CCmdConnect::WaitForNextEvent(TInt aEventType)
	{
	// Wait for the next event
	iEventRequired	= aEventType;

	iEventDispatcher->WaitForWspEvent();
	}


void CCmdConnect::HandleWspEvent(TRequestStatus aStatus)
{
	TBool fail = EFalse;
	
	if (aStatus == THTTPSessionEvent::EConnect)
		{
		Log(_L("CFrmwrkSession::HandleWspEvent, event EConnect"));
		} 
	else if (aStatus == THTTPSessionEvent::EConnectedOK)
		{
		Log(_L("CFrmwrkSession::HandleWspEvent, event EConnectedOK"));
		}
	else if (aStatus == THTTPSessionEvent::EConnectedWithReducedCapabilities)
		{
		Log(_L("CFrmwrkSession::HandleWspEvent, event EConnectedWithReducedCapabilities"));
		}
	else if (aStatus == THTTPSessionEvent::EDisconnected)
		{
		Log(_L("CFrmwrkSession::HandleWspEvent, event EDisconnected"));
		fail = ETrue;
		}
	else if (aStatus == THTTPSessionEvent::EAuthenticatedOK)
		{
		Log(_L("CFrmwrkSession::HandleWspEvent, event EAuthenticatedOK"));
		} 
	else if (aStatus == THTTPSessionEvent::EAuthenticationFailure)
		{
		Log(_L("CFrmwrkSession::HandleWspEvent, event EAuthenticationFailure"));
		}
	else if (aStatus == THTTPSessionEvent::EConnectionTimedOut)
		{
		Log(_L("CFrmwrkSession::HandleWspEvent, event EConnectionTimedOut"));
		fail = ETrue;
		}
	else
		{
	    Log(_L("CFrmwrkSession::HandleWspEvent, Unrecognised event [%d]"), aStatus.Int());
		fail = ETrue;
		}

	if (fail)
		{
		CObjCatalogue *sessions = Machine()->Domains();

		for (TInt i = 0; i < sessions->Count(); ++i)
			{
			CAnyObject *obj = (CAnyObject *)sessions->At(i);
			if (obj->Tag() == THA_KHTTP_Connect)
				{
				CFrmwrkSession *frmwk = (CFrmwrkSession *) obj->Ptr();

				if (frmwk->UseWSPProtocol() && (frmwk->iState == CFrmwrkSession::EWSPDisconnected))
				{
					TBuf16<256> myNameBuf;
	
					myNameBuf.Copy(frmwk->Name());
		
					Log(_L("CCmdConnect::HandleWspEvent() : Delete %S\r\n"), &myNameBuf);
					Delete(myNameBuf);
					Machine()->Domains()->Delete(myNameBuf);
		
					}
				}
			}
		}
		
	WaitForNextEvent (THTTPSessionEvent::EDisconnected);
}

//-----------------------------------------------------------------------------
// End of File
//-----------------------------------------------------------------------------