#include "ut_testenv.h"

#include <etel.h>

#include <etelmm.h>

#include <etelmmcs.h>

#include <QTest>

// global variables

CPeriodic* messageResponseTimer = 0;

// ==============================================================================

// RMobileUssdMessaging

// ==============================================================================

RMobileUssdMessaging::RMobileUssdMessaging()

{

}

RMobileUssdMessaging::RMobileUssdMessaging(const RMobileUssdMessaging&)

{

}

void RMobileUssdMessaging::ConstructL()

{

	QVERIFY(!messageResponseTimer);

    messageResponseTimer =

		CPeriodic::NewL(CActive::EPriorityStandard+1);

}

TInt RMobileUssdMessaging::Open(RMobilePhone& /*aPhone*/)

{

	TRAPD(err,ConstructL());

    return err;

}

void RMobileUssdMessaging::Close()

{

	delete messageResponseTimer;

	messageResponseTimer = 0;

}

void RMobileUssdMessaging::Destruct()

{

}

TInt RMobileUssdMessaging::GetCaps(TDes8& aCaps) const

{

    TMobileUssdCapsV1 caps;

    caps.iUssdFormat = KCapsPackedString;

    caps.iUssdTypes = KCapsMTUssd | KCapsMOUssd;

    TMobileUssdCapsV1Pckg pckgCaps( caps );

    aCaps.Copy( pckgCaps );

    return KErrNone;

}

void RMobileUssdMessaging::ReceiveMessage(

    TRequestStatus& aReqStatus, TDes8& aMsgData,

    TDes8& aMsgAttributes) const

{

	EtelMsgLoop& loop = TestEnv::env().etelMsgLoop();

    QVERIFY2(!loop.mReceiveMessageReqStatus,

    		"etel_mock: ReceiveMessage called twice!");

    aReqStatus = KRequestPending;

    loop.mReceiveMessageReqStatus = &aReqStatus;

	loop.mReceiveMessageData = &aMsgData;

	loop.mReceiveMessageAttributes = &aMsgAttributes;

}

TInt SendMessageCallback(TAny* /*aPtr*/)

	{

	messageResponseTimer->Cancel();

	EtelMsgLoop& loop = TestEnv::env().etelMsgLoop();

    const TestMode& mode = TestEnv::env().testMode();

    if (mode.m_event == TestMode::Normal)

    	{

    	User::RequestComplete(loop.mSendMessageReqStatus, mode.m_error);

    	}

    return 0;

	}

void RMobileUssdMessaging::SendMessage(

    TRequestStatus& aReqStatus, const TDesC8& /*aMsgData*/,

    const TDesC8& /*aMsgAttributes*/) const

{

	EtelMsgLoop& loop = TestEnv::env().etelMsgLoop();

    QVERIFY2(!loop.mSendMessageReqStatus,

    		"etel_mock: SendMessage called twice!");

    aReqStatus = KRequestPending;

    loop.mSendMessageReqStatus = &aReqStatus;

    const TestMode& mode = TestEnv::env().testMode();

    if (mode.m_event != TestMode::NoResp)

    	{

		// start timer to respond

		TTimeIntervalMicroSeconds32 delay(

				1000*mode.m_timeout);

		messageResponseTimer->Start(delay,delay,

				TCallBack(SendMessageCallback,(TAny*)this));

    	}

}

void RMobileUssdMessaging::SendMessageNoFdnCheck(

    TRequestStatus& /*aReqStatus*/, const TDesC8& /*aMsgData*/,

    const TDesC8& /*aMsgAttributes*/) const

{

	// not used

}

void RMobileUssdMessaging::SendRelease(

    TRequestStatus& /*aReqStatus*/, TDes8& /*aReturnResult*/) const

{

	// not used

}

void RMobileUssdMessaging::NotifyNetworkRelease(

    TRequestStatus& aReqStatus, TDes8& aReturnResult) const

{

	EtelMsgLoop& loop = TestEnv::env().etelMsgLoop();

    QVERIFY2(!loop.mNetworkReleaseReqStatus,

    		"etel_mock: NotifyNetworkRelease called twice!");

    aReqStatus = KRequestPending;

    loop.mNetworkReleaseReqStatus = &aReqStatus;

	loop.mNetworkReleaseMessageData = &aReturnResult;

	loop.mNetworkReleaseMessageAttributes = 0;

}

void RMobileUssdMessaging::NotifyNetworkRelease(

    TRequestStatus& aReqStatus, TDes8& aMsgData,

    TDes8& aMsgAttributes) const

{

	EtelMsgLoop& loop = TestEnv::env().etelMsgLoop();

    QVERIFY2(!loop.mNetworkReleaseReqStatus,

    		"etel_mock: NotifyNetworkRelease called twice!");

    aReqStatus = KRequestPending;

    loop.mNetworkReleaseReqStatus = &aReqStatus;

	loop.mNetworkReleaseMessageData = &aMsgData;

	loop.mNetworkReleaseMessageAttributes = &aMsgAttributes;

}

RMobileUssdMessaging::TMobileUssdAttributesV1::TMobileUssdAttributesV1()

{

    iFlags = 0;

    iFormat = EFormatUnspecified;

    iType = EUssdUnknown;

    iDcs = 0;

}

RMobileUssdMessaging::TMobileUssdCapsV1::TMobileUssdCapsV1()

{

    iUssdFormat = 0;

    iUssdTypes = 0;

}

// ==============================================================================

// RMobilePhone

// ==============================================================================

RMobilePhone::TMobilePhoneSendSSRequestV3::TMobilePhoneSendSSRequestV3()

{

    iOpCode = 0;

}

RMobilePhone::TMultimodeType::TMultimodeType()

{

    iExtensionId = 0;

}

// ==============================================================================

// RTelSubSessionBase

// ==============================================================================

RTelSubSessionBase::RTelSubSessionBase()

{

}

void RTelSubSessionBase::CancelAsyncRequest(TInt aReqToCancel) const

{

	if ( aReqToCancel == EMobileUssdMessagingSendMessage )

	{

		EtelMsgLoop& loop = TestEnv::env().etelMsgLoop();

		if ( loop.mSendMessageReqStatus )

		{

		User::RequestComplete( loop.mSendMessageReqStatus, KErrCancel );

		}

	}

	else if ( aReqToCancel == EMobileUssdMessagingReceiveMessage )

	{

		EtelMsgLoop& loop = TestEnv::env().etelMsgLoop();

		if ( loop.mReceiveMessageReqStatus )

    	{

        User::RequestComplete( loop.mReceiveMessageReqStatus, KErrCancel );

    	}

	}

	else if ( aReqToCancel == EMobileUssdMessagingNotifyNetworkRelease )

	{

		EtelMsgLoop& loop = TestEnv::env().etelMsgLoop();

		if ( loop.mNetworkReleaseReqStatus )

    	{

        User::RequestComplete( loop.mNetworkReleaseReqStatus, KErrCancel );

    	}

	}

	else if ( aReqToCancel == EMobileUssdMessagingSendRelease )

	{

	// not used

	}

}