// 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 <e32std.h>

//

#include "Dummywapstd.h"

#include "dummywapstack.h"

#include "dummycapcodec.h"

const TInt KWapStkArrayGranualarity=1;

/**

 * Factory construction method

 * Use this method to allocate and construct a new CDummyWapStack object

 */

 EXPORT_C CDummyWapStack* CDummyWapStack::NewL(MDummyWapStackObserver& aObserver)

	{

	CDummyWapStack* self=new (ELeave) CDummyWapStack(aObserver);

	CleanupStack::PushL(self);	

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	};

/**

 * Constructor

 */

CDummyWapStack::CDummyWapStack(MDummyWapStackObserver& aObserver) :iObserver(aObserver),iSessionsArray(KWapStkArrayGranualarity)

	{

	}

/**

 * 2nd phase constructor

 * If the server instance hasn't already been constructed, create one

 * and store the pointer in thread local storage

 */

void CDummyWapStack::ConstructL()

	{

	if(!iInstance)

		{

		User::LeaveIfError(Dll::SetTls(this));

		iInstance = StackInstance();

		}

	}

/**

 * Destructor

 */

CDummyWapStack::~CDummyWapStack()

	{

	FreeTls();

	iInstance =NULL;

	iObserver.DWSOServerShutDown();

	__ASSERT_DEBUG(iSessionsArray.Count()==0, User::Panic(_L("Session Not deleted  != 0"), 0));

	iSessionsArray.Close();

	}

/**

 * Removes the pointer stored in TLS and zero it

 */

void  CDummyWapStack::FreeTls()

	{

	Dll::FreeTls();

	Dll::SetTls(NULL);

	}

/**

 * Return the newly created session

 */

EXPORT_C CDummyWapSession* CDummyWapStack::NewSessionL()

	{

	CDummyWapSession* Session = CDummyWapSession::NewL();

	CleanupStack::PushL(Session);

	User::LeaveIfError(iSessionsArray.Append(Session));

	CleanupStack::Pop(); 	  

	return iSessionsArray[iSessionsArray.Count()-1];

	}

/**

 * Close the session with the server by removing it from the array 

 * of open sessions 

 * @param aDummyWapSession The session to be closed

 */

EXPORT_C void CDummyWapStack::CloseSession(CDummyWapSession* aDummyWapSession)

	{

	for(TInt loop=iSessionsArray.Count();--loop>=0;)

		{

		if (iSessionsArray[loop]==aDummyWapSession)

			{

			iSessionsArray.Remove(loop);

			delete aDummyWapSession;

			break;

			}

		}

	}

/**

 * Return a reference to the MDummyWapStackObserver 

 */

EXPORT_C MDummyWapStackObserver& CDummyWapStack::Observer()

	{

	return iObserver;

	}

/**

 *  Factory method to create new CDummyWapSession object

 */

CDummyWapSession* CDummyWapSession::NewL()

	{

	CDummyWapSession* self = new(ELeave) CDummyWapSession();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self); 

	return self;

	}

/**

 * 2nd phase constructor

 */

void CDummyWapSession::ConstructL()

	{

	}

/**

 * Destructor

 */

CDummyWapSession::~CDummyWapSession()

	{

	// check that all sessions have been closed

	__ASSERT_ALWAYS(iReferenceCount==0,User::Invariant());

	}

/**

 * Creates a new CL connection

 */

CDummyWSPCLConn*  CDummyWapSession::NewWSPCLConnL(TPort aPort)

	{

	CDummyWSPCLConn* dummyCL = new (ELeave) CDummyWSPCLConn(*this, aPort);

	iReferenceCount++;

	return dummyCL;

	}

/**

 * Creates a new CO connection

 */

CDummyWSPCOConn* CDummyWapSession::NewWSPCOConnL()

	{

	CDummyWSPCOConn* dummyCO = new (ELeave) CDummyWSPCOConn(*this);

	iReferenceCount++;

	return dummyCO;

	}

/**

 * Close a connection (subsession)

 */

void CDummyWapSession::Close()

	{

	// check that there is a session open to close

	__ASSERT_ALWAYS(iReferenceCount>0, User::Invariant());

	iReferenceCount--;

	}

/**

 * Constructor 

 * @param aSession Wap stack client session that created the connection

 */

CDummyWSPConn::CDummyWSPConn(CDummyWapSession& aSession) : iSession(aSession)

	{

	}

/**

 * Virtual close method for all "dummy" wap connections

 */

void CDummyWSPConn::Close()

	{

	iSession.Close();

	delete iWtls;

	delete this;

	}

/** 

 * Get a pointer to the WTLS implementation from the testcode

 */

CDummyWTLS* CDummyWSPConn::WtlsL()

	{

	if (!iWtls)

		{

		iWtls = new (ELeave) CDummyWTLS();

		}

	return iWtls;

	}

/**

 * simple constructor - call the base class

 * @param aSession Wap stack client session that created the connection

 */

CDummyWSPCLConn::CDummyWSPCLConn(CDummyWapSession& aSession,TPort aLocalPort) :

	CDummyWSPConn(aSession),iLocalPort(aLocalPort)

	{

	}

/**

 * Destructor

 */

CDummyWSPCLConn::~CDummyWSPCLConn()

	{

	delete iPushHeadersData;

	delete iPushBodyData;

	delete iServerAddr;

	}

TInt CDummyWSPCLConn::Connect(Wap::TBearer /*aBearer*/, Wap::TPort /*aPort*/, TBool /*aSecure*/)

	{

	TInt err = KErrNone;

	return err;

	}

TInt CDummyWSPCLConn::AwaitPush(TDes8& aPushHeaders, TDes8& aPushBody, TPckgBuf<TUint8>& aPushId, TRequestStatus& aReqStatus)

	{

	TPushID pushID;

	pushID() = aPushId();

	TRAPD(err, UnitWaitPushL(aPushBody, aPushHeaders, pushID, aReqStatus));

	return err;

	}

/**

 * 

 */

void CDummyWSPCLConn::UnitWaitPushL(TDes8& aBody,TDes8& aHeaders,TPushID& aID,TRequestStatus& aStatus)

	{

	__ASSERT_DEBUG(aBody.MaxSize()>0, User::Panic(_L("Msg Body Buffer Not Allocated"),0));

	__ASSERT_DEBUG(aHeaders.MaxSize()>0, User::Panic(_L("Msg Header Buffer Not Allocated"),0));

	aStatus=KRequestPending;

	//point to the Msg Buffers

	iClientBody=&aBody;

	iClientHeaders=&aHeaders;

	iID = &aID;

	iStatus=(&aStatus);

	//Initialise Buffers to zero Before Appending 

	iClientBody->Zero();

	iClientHeaders->Zero();

	*iID =0;

	//Invoke the dummy Observer UnitWaitPush

	STATIC_CAST(CDummyWapStack* , Dll::Tls())->Observer().DWSOUnitWaitPushL(*this);

	}

TInt CDummyWSPCLConn::CancelAwaitPush()

	{

	return CancelUnitWaitPush();

	}

/**

 * Cancel a unit wait push

 */

TInt CDummyWSPCLConn::CancelUnitWaitPush()

	{

 	if (iClientBody)

		iClientBody->Zero();

	if (iClientHeaders)

		iClientHeaders->Zero();

//	if (iID)

//		*iID =0;

	STATIC_CAST(CDummyWapStack* , Dll::Tls())->Observer().DWSOCancelUnitWaitPush(*this);

	User::RequestComplete(iStatus,KErrCancel);

	return KErrNone;

	}

/**

 * -Reads in the whole Msg. Header & Body From the WSS stack 

 * (i.e the test Harness) and Creates a Local Copy.

 * -Copy the Msg. Header & Body to Watcher Buffers:

 *		if the Watcher Buffers are big enough to hold the message,

 *		then the whole Mgs is copied and we Complete with KErrNone.

 *		if the Watcher Buffers are smaller then the Msg is copied 

 *      in blocks of size equal to the size of the Watcher Buffers

 *      completing with EMoreData every time until the watcher gets

 *		the whole Msg. At that point there is no more data to be 

 *		copied then we complete with KErrNone.

 */

EXPORT_C void CDummyWSPCLConn::CompleteUnitWaitPushL(TDes8& aBody,TDes8& aHeaders)

	{

	TPushID id;

	id=99;

	// Only read data from the WSS stack the first call

	if (iPushHeadersDataOffset == 0 && iPushBodyDataOffset == 0) 

		{

		__ASSERT_DEBUG(iPushHeadersData == 0, User::Panic(_L("headers != 0"), 0));

		__ASSERT_DEBUG(iPushBodyData == 0, User::Panic(_L("body != 0"), 0));

		TUint bodySize = aBody.Size();

		TUint headersSize =aHeaders.Size();		

		if (bodySize==0 && headersSize==0) 

			User::Leave(RWSPCLConn::EDataNotAvailable);

		iPushHeadersData= aHeaders.AllocL();

		iPushBodyData= aBody.AllocL();

		*iID=id;//**** Generate an Id per Msg, Not Supported in R1

		iPushHeadersData->Des().SetLength(headersSize);

		iPushBodyData->Des().SetLength(bodySize);

		}

	TInt clientHeadersSize = iClientHeaders->MaxSize();

	TInt clientBodySize = iClientBody->MaxSize();

	TInt headersRetSize = Min(clientHeadersSize, (iPushHeadersData->Size() - iPushHeadersDataOffset));

	TInt bodyRetSize = Min(clientBodySize, (iPushBodyData->Size() - iPushBodyDataOffset));

	iClientHeaders->Append(iPushHeadersData->Mid(iPushHeadersDataOffset, headersRetSize));

	iClientBody->Append(iPushBodyData->Mid(iPushBodyDataOffset, bodyRetSize));

	iPushHeadersDataOffset += headersRetSize;

	iPushBodyDataOffset += bodyRetSize;

	__ASSERT_DEBUG(iPushBodyDataOffset <= iPushBodyData->Size(), User::Panic(_L("Body offset too big"), 0));

	__ASSERT_DEBUG(iPushHeadersDataOffset <= iPushHeadersData->Size(), User::Panic(_L("Headers offset too big"), 0));

	// Are we done yet?

	if (iPushHeadersDataOffset == iPushHeadersData->Size() &&

		iPushBodyDataOffset == iPushBodyData->Size() )

		{

		delete iPushHeadersData;

		delete iPushBodyData;

		iPushHeadersData = 0;

		iPushBodyData = 0;

		iPushHeadersDataOffset = 0;

		iPushBodyDataOffset = 0;

		User::RequestComplete(iStatus,KErrNone);

		}

	else

		User::RequestComplete(iStatus,RWAPConn::EMoreData);

	}

EXPORT_C TBool CDummyWSPCLConn::HasMsgBeenCompleted()

	{

	return (iPushHeadersDataOffset == 0 && iPushBodyDataOffset == 0);

	}

/**

 * Sync Version

 */

TInt CDummyWSPCLConn::UnitWaitPushL(TDes8& /*aBody*/,TDes8& /*aHeaders*/,TPushID& /*aID*/)

	{

	return KErrNotSupported;

	}

/**

 * simple constructor - call the base class

 * @param aSession Wap stack client session that created the connection

 */

CDummyWSPCOConn::CDummyWSPCOConn(CDummyWapSession& aSession) : CDummyWSPConn(aSession), iSessionState(RWSPCOConn::EInit), iTransArray(1)

	{

	}

/**

 * Destructor

 */

CDummyWSPCOConn::~CDummyWSPCOConn()

	{

	// assert that the connection has been disconnected if it was connected?

	__ASSERT_ALWAYS(iCapCodec==NULL,User::Invariant());

	__ASSERT_ALWAYS(iTransArray.Count()==0, User::Panic(_L("Transaction not closed"), 0));

	iTransArray.Close();

	}

/**

 * Establish a connection-orientated WSP session with the server

 *

 * Takes ownership of the aCap parameter (the client's capabilities)

 * Informs the testcode (via the mixin) of the connect request so that

 * it can decide whether to confirm the connection. 

 */

TInt CDummyWSPCOConn::Connect(const TDesC8& aClientHeaders, class CCapCodec* /*aCap*/)

	{

	iClientHeaders=&aClientHeaders;

	iSessionState=RWSPCOConn::EConnecting;

	static_cast<CDummyWapStack*>(Dll::Tls())->Observer().DWSOConnect(*this);

	return KErrNone;

	}

/**

 * Disconnects the session and abort all pending transactions

 */

TInt CDummyWSPCOConn::Disconnect()

	{

	iSessionState=RWSPCOConn::EDisconnected;

	TInt numTrans=iTransArray.Count();

	while(numTrans>0)

		{

		CDummyWSPCOTrans* trans = iTransArray[0];

		trans->Abort(99); //TODO

		iTransArray.Remove(0);

		numTrans--;

		}

	return KErrNone;

	}

/**

 * Return the state of a session

 */

TInt CDummyWSPCOConn::GetSessionState(RWSPCOConn::TSessionState& aState)

	{

	aState=iSessionState;

	return KErrNone;

	}

/**

 * Gets the next session or transaction event on this session

 * 

 * Stores the parameters supplied by the client and awaits callback from 

 * the testcode

 */

TInt CDummyWSPCOConn::GetEvent(RWSPCOConn::TEvent& aEvent, RWSPCOTrans& aTrans, TRequestStatus& aStatus)

	{

	aStatus=KRequestPending;

	iStatus=&aStatus;

	iEvent=&aEvent;

	iTrans=&aTrans;

	//Invoke the dummy Observer GetEvent

	static_cast<CDummyWapStack*>(Dll::Tls())->Observer().DWSOGetEventL(*this);

	return KErrNone;

	}

/**

 * Cancel a get event request

 */

EXPORT_C void CDummyWSPCOConn::CancelGetEvent()

	{

	static_cast<CDummyWapStack*>(Dll::Tls())->Observer().DWSOCancelGetEvent(*this);

	if (iStatus)

		User::RequestComplete(iStatus,KErrCancel);

	}

/**

 * Return the number of events pending for the session

 */

TInt CDummyWSPCOConn::GetNrOfEvents(TUint& aNrOfEvents)

	{

	//ask the testcode?

	aNrOfEvents=0;

	return KErrNone;

	}

/**

 * Complete the GetEvent call

 * Called by the test harness to indicate that the transaction handle 

 * has been set. Adds the dummy transaction to the array of transactions

 * stored in the connection, then completes the asynchronous request.

 * 

 */

EXPORT_C void CDummyWSPCOConn::CompleteGetEventL(RWSPCOConn::TEvent& aEvent, CDummyWSPCOTrans& aDummyTrans)

	{

	*iEvent=aEvent;

	iTrans->iCoTransHandle=&aDummyTrans;

	User::LeaveIfError(iTransArray.Append(&aDummyTrans));

	//TInt count = iTransArray.Count(); //REMOVE THIS LINE!

	User::RequestComplete(iStatus,KErrNone); 

	}

/**

 * Remove a transaction pending on this connection. 

 * This should be called by the transaction if the transaction is aborted

 * or released. It will remove the transaction from the list of transactions

 */

void CDummyWSPCOConn::RemoveTransaction(CDummyWSPCOTrans& aTrans)

	{

	RWSPCOTrans::TTransID id;

	aTrans.Id(id);

	RWSPCOTrans::TTransID transId;

	TInt count = iTransArray.Count();