/*

* Copyright (c) 2005 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 "MCETestHelper.h"

#include "mcesipsession.h"

#include "mcesipevent.h"

#include "mcecssession.h"

#include "mcecssessionimplementation.h"

#include "mceservercore.h"

#include "SIPExpiresHeader.h"

#include "SIPEventHeader.h"

#include "mcereliablesender.h"

#include "sipsupportedheader.h"

#include "siprackheader.h"

#include <siprequireheader.h>

#include <siprseqheader.h>

#include <sipcontactheader.h>

_LIT8(KFmtAttribute,"a=fmtp:TBCP format parameters\r\n");

_LIT8(KFmtAttribute2,"a=fmtp:TestPlugIn format parameters\r\n");

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

// MCETestHelper::ClientCreateSessionL()

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

//

CMceSipSession* MCETestHelper::ClientCreateSessionL( CMceCsSession* aClient, 

                                                     const TDesC8& aParam1, 

                                                     const TDesC8& aParam2 )

    {

    TMceIds& ids = CMCETls::Storage()->iIds;

	CDesC8ArrayFlat* params = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

	CleanupStack::PushL( params );

	params->AppendL( aParam1 );

	params->AppendL( aParam2 );

    CMceMsgTextArray* msgParams = new (ELeave) CMceMsgTextArray( *params );

    CleanupStack::PushL( msgParams );

    CMCETls::Storage()->StoreL( ids, *msgParams );

    CleanupStack::PopAndDestroy( msgParams );

    CleanupStack::PopAndDestroy( params );

    TInt count = aClient->Implementation().SubSessions().Count();

    aClient->CreateSubSessionL(ids, RMessage2() );

    return static_cast<CMceSipSession*>(aClient->Implementation().SubSessions()[ count ]);

    }

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

// MCETestHelper::ManagerReadyToReceiveL()

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

//

void MCETestHelper::ManagerReadyToReceiveL( CMceCsSession* aClient )

    {

    TMceIds& ids = CMCETls::Storage()->iManagerIds;

    CMCETls::Storage()->iIdsIndex = 1;

    aClient->ClientReadyToReceiveL( ids, RMessage2() );

    CMCETls::Storage()->iIdsIndex = 0;

    }

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

// MCETestHelper::ClientReadyToReceiveL()

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

//

void MCETestHelper::ClientReadyToReceiveL( CMceSipSession* aSession )

    {

    TMceIds& ids = CMCETls::Storage()->iIds;

	delete CMCETls::Storage()->iContextServer;

	delete CMCETls::Storage()->iContentServer;

	CMCETls::Storage()->iContextServer = NULL;

	CMCETls::Storage()->iContentServer = NULL;

	CMCETls::Storage()->iMessageSizes = TMceMessageBufSizes();

    //client ready to receive

    ids.iSessionID = reinterpret_cast<TUint32>( aSession );

    aSession->ServiceL( ids, EMceItcClientReadyToReceive, RMessage2() );

    }

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

// MCETestHelper::ClientReceiveLC()

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

//

CMceMsgBase* MCETestHelper::ClientReceiveLC( CMceSipSession* aSession, TMceIds& aIds )

    {

    CMceMsgBase* message = NULL;

    TMceIds& ids = CMCETls::Storage()->iIds;

    aIds = ids;

    if ( CMCETls::Storage()->iMessageSizes.iContextBufSize > 0 )

        {

        //client receive

        aSession->ServiceL( ids, EMceItcReceive, RMessage2() );

        //client code

    	RDesReadStream readStream( *CMCETls::Storage()->iContextServer );

        CleanupClosePushL( readStream );

        message = TMceComFactory().CreateL( (TMceItcDataType)ids.iMsgType,

                                                         readStream );

    	CleanupStack::PopAndDestroy(); // readStream

        }

    ClientReadyToReceiveL( aSession );

	if ( message )

	    {

    	CleanupStack::PushL( message );

	    message->PushL();

	    }

    return message;    

    }

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

// MCETestHelper::ClientEstablishL()

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

//

CMceComSession* MCETestHelper::ClientEstablishL( CMceSipSession* aSession,

                                                 const TDesC8& aHeader,

                                                 const TDesC8& aContentType,

                                                 const TDesC8& aContent,

                                                 TBool aRequire100rel )

    {

    TMceIds& ids = CMCETls::Storage()->iIds;

    CMceComSession* clientSession = ComSessionL( ids.iSessionID, aRequire100rel );

    CleanupStack::PushL( clientSession );

    if ( clientSession->iSIPHeaders->MdcaCount() > 0 && aHeader.Length() == 0 )

        {

        clientSession->iSIPHeaders->Delete( 0, clientSession->iSIPHeaders->MdcaCount() );

        }

    if ( aHeader.Length() > 0 )

        {

        clientSession->iSIPHeaders->AppendL( aHeader );

        }

    MCE_TH_SET( clientSession->iSIPContentType, NULL );

    clientSession->iSIPContentType = aContentType.AllocL();

    CMceMsgObject<CMceComSession>* clientSessionMsg = 

        new (ELeave) CMceMsgObject<CMceComSession>( *clientSession, EMceItcMsgTypeSession );

    CleanupStack::PushL( clientSessionMsg );

    HBufC8* content = aContent.AllocLC();

    CMCETls::Storage()->StoreL( ids, *clientSessionMsg, content );

    CleanupStack::Pop( content );

    CleanupStack::PopAndDestroy( clientSessionMsg );

    //establish

    aSession->ServiceL( ids, EMceItcEstablishSession, RMessage2() );

    CMCETls* storage = CMCETls::Storage();

  	MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse && 

  	   ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError || 

  	     storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )

    CleanupStack::Pop( clientSession );

    return clientSession;

    }

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

// MCETestHelper::ClientTerminateL()

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

//

void MCETestHelper::ClientTerminateL( CMceSipSession* aSession, 

                                      const TDesC8& aHeader,

                                      const TDesC8& aContentType,

                                      const TDesC8& aContent )

    {

    TMceIds& ids = CMCETls::Storage()->iIds;

    ids.iSessionID = aSession->Body()->Id();

    if ( aHeader.Length() == 0 && aContentType.Length() == 0 && aContent.Length() == 0 )

        {

        ids.iMsgType = KMceNotAssigned;

        aSession->ServiceL( ids, EMceItcTerminateSession, RMessage2() );

        return;

        }

    HBufC8* content = aContent.AllocLC();

    HBufC8* contentType = aContentType.AllocLC();

    CDesC8Array* headers = NULL;

    if ( aHeader.Length() > 0 )

        {

        headers = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

        CleanupStack::PushL( headers );

        headers->AppendL( aHeader );

        }

    CMceMsgSIPData* sipData = new (ELeave) CMceMsgSIPData( SipStrConsts::EBye,

                                                           *headers, *contentType );

    CleanupStack::PushL( sipData );

    CMCETls::Storage()->StoreL( ids, *sipData, content );

    CleanupStack::PopAndDestroy( sipData );

    if ( headers )

        CleanupStack::PopAndDestroy( headers );

    CleanupStack::PopAndDestroy( contentType );

    CleanupStack::Pop( content );

    //reject session

    aSession->ServiceL( ids, EMceItcTerminateSession, RMessage2() );

    CMCETls* storage = CMCETls::Storage();

  	MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse && 

  	   ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError || 

  	     storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )

    }

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

// MCETestHelper::ClientAcceptL()

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

//

void MCETestHelper::ClientAcceptL( CMceSipSession* aSession,

                                    const TDesC8& aReason, 

                                    TInt aReasonCode )

    {

    TMceIds& ids = CMCETls::Storage()->iIds;

    ids.iSessionID = aSession->Body()->Id();

    CDesC8Array* headers = NULL;

    HBufC8* reason = NULL;

    HBufC8* ctype = NULL;

    if ( aReasonCode == -1 )

        {

        ids.iMsgType = KMceNotAssigned;

        aSession->ServiceL( ids, EMceItcAcceptSession, RMessage2() );

        CMCETls* storage = CMCETls::Storage();

      	MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse && 

      	   ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError || 

      	     storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )

        return;

        }

    if ( aReasonCode == 0 )

        {

        aReasonCode = KMceSipOK;

        }

    if ( aReason.Length() > 0 )

        {

        reason = aReason.AllocLC();

        }

    else

        {

        reason = SIPStrings::StringF( SipStrConsts::EPhraseOk ).DesC().AllocLC();

        }

    CMceMsgSIPReply* reply = new (ELeave) CMceMsgSIPReply( *reason, (TUint32)aReasonCode, *headers, *ctype );

    CleanupStack::PushL( reply );

    CMCETls::Storage()->StoreL( ids, *reply, NULL );

    CleanupStack::PopAndDestroy( reply );

    CleanupStack::PopAndDestroy( reason );

    aSession->ServiceL( ids, EMceItcAcceptSession, RMessage2() );

    CMCETls* storage = CMCETls::Storage();

  	MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse && 

  	   ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError || 

  	     storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )

    }

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

// MCETestHelper::ClientDeclineL()

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

//

void MCETestHelper::ClientDeclineL( CMceSipSession* aSession, 

                                    const TDesC8& aHeader, 

                                    const TDesC8& aContent,

                                    const TDesC8& aContentType,

                                    const TDesC8& aReason, 

                                    TInt aReasonCode )

    {

    TMceIds& ids = CMCETls::Storage()->iIds;

    ids.iSessionID = aSession->Body()->Id();

    if ( aReasonCode == -1 )

        {

        ids.iMsgType = KMceNotAssigned;

        aSession->ServiceL( ids, EMceItcRejectSession, RMessage2() );

        return;

        }

    if ( aReasonCode == 0 )

        {

        aReasonCode = KMceSipDecline;

        }

    HBufC8* content = NULL;

    HBufC8* reason = NULL;

    HBufC8* ctype = NULL;

    CDesC8Array* headers = NULL;

    if ( aContent.Length() > 0 )

        {

        content = aContent.AllocLC();

        }

    if ( aReason.Length() > 0 )

        {

        reason = aReason.AllocLC();

        }

    else

        {

        reason = SIPStrings::StringF( SipStrConsts::EPhraseDecline ).DesC().AllocLC();

        }

    if ( aHeader.Length() > 0 )

        {

        headers = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

        CleanupStack::PushL( headers );

        headers->AppendL( aHeader );

        }

    if ( aContentType.Length() > 0 )

        {

        ctype = aContentType.AllocLC();

        }

    CMceMsgSIPReply* reply = new (ELeave) CMceMsgSIPReply( *reason, (TUint32)aReasonCode, *headers, *ctype );

    CleanupStack::PushL( reply );

    CMCETls::Storage()->StoreL( ids, *reply, content );

    CleanupStack::PopAndDestroy( reply );

    if ( ctype )

        CleanupStack::PopAndDestroy( ctype );

    if ( headers )

        CleanupStack::PopAndDestroy( headers );

    if ( reason )

        CleanupStack::PopAndDestroy( reason );

    if ( content )

        CleanupStack::Pop( content );

    //reject session

    aSession->ServiceL( ids, EMceItcRejectSession, RMessage2() );

    }

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

// MCETestHelper::ClientRingL()

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

//

void MCETestHelper::ClientRingL( CMceSipSession* aSession, 

                                    const TDesC8& aHeader, 

                                    const TDesC8& aContent,

                                    const TDesC8& aContentType )

    {

    TMceIds& ids = CMCETls::Storage()->iIds;

    ids.iSessionID = aSession->Body()->Id();

    if ( aHeader.Length() == 0 && aContentType.Length() == 0 && aContent.Length() == 0 )

        {

        ids.iMsgType = KMceNotAssigned;

        aSession->ServiceL( ids, EMceItcRing, RMessage2() );

        CMCETls* storage = CMCETls::Storage();

      	MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse && 

      	   ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError || 

      	     storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )

        return;

        }

    TUint32 reasonCode = KMceSipRinging;

    HBufC8* content = NULL;

    HBufC8* reason = NULL;

    HBufC8* ctype = NULL;

    CDesC8Array* headers = NULL;

    content = aContent.AllocLC();

    reason = SIPStrings::StringF( SipStrConsts::EPhraseRinging ).DesC().AllocLC();

    if ( aHeader.Length() > 0 )

        {

        headers = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

        CleanupStack::PushL( headers );

        headers->AppendL( aHeader );

        }

    ctype = aContentType.AllocLC();

    CMceMsgSIPReply* reply = new (ELeave) CMceMsgSIPReply( *reason, reasonCode, *headers, *ctype );

    CleanupStack::PushL( reply );

    CMCETls::Storage()->StoreL( ids, *reply, content );

    CleanupStack::PopAndDestroy( reply );

    CleanupStack::PopAndDestroy( ctype );

    if ( headers )

        CleanupStack::PopAndDestroy( headers );

    CleanupStack::PopAndDestroy( reason );

    CleanupStack::Pop( content );

    aSession->ServiceL( ids, EMceItcRing, RMessage2() );

    CMCETls* storage = CMCETls::Storage();

  	MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse && 

  	   ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError || 

  	     storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )

    }

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

// MCETestHelper::ClientCancelL()

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

//

void MCETestHelper::ClientCancelL( CMceSipSession* aSession )

    {

    TMceIds& ids = CMCETls::Storage()->iIds;

    ids.iSessionID = aSession->Body()->Id();

    ids.iMsgType = KMceNotAssigned;

    aSession->ServiceL( ids, EMceItcCancel, RMessage2() );

    CMCETls* storage = CMCETls::Storage();

  	MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse && 

  	   ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError || 

  	     storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )

    }

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

// MCETestHelper::ClientIncomingSessionL()

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

//

CMceSipSession* MCETestHelper::ClientIncomingSessionL( CMceCsSession* aClient, 

                                                       TBool aInvalid,

                                                       TBool aSupported100rel )

    {

    CMceSipSession* session = NULL;

    TUint32 iapId = 1;

    //invite

    CSIPServerTransaction* invite = NULL;

    if ( !aInvalid )

        {

        RPointerArray<CSIPHeaderBase> hdrs;

        CSIPHeaderBase::PushLC( &hdrs );

        if ( aSupported100rel )

            {

            RStringF supp100rel = SIPStrings::Pool().OpenFStringL( KMceSip100Rel );

            CleanupClosePushL( supp100rel );

            CSIPSupportedHeader* supported = 

                CSIPSupportedHeader::NewLC( supp100rel );

            hdrs.AppendL( supported );

            CleanupStack::Pop( supported );

            CleanupStack::PopAndDestroy(); // supp100rel

            }

        invite = ServerTransactionL( SipStrConsts::EInvite, hdrs, ETrue );

        CleanupStack::Pop( &hdrs );

        }

    else

        {

        invite = ServerTransactionBadSDPL( SipStrConsts::EInvite );

        }

  	aClient->ServerCore().Manager().IncomingRequest( iapId, invite );

  	CMCETls* storage = CMCETls::Storage();

  	MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse && 

  	   ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError || 

  	     storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )

  	storage->ExecuteCallback();

  	MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse && 

  	   ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError || 

  	     storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )

    TInt count = aClient->Implementation().SubSessions().Count();

    if ( count > 0 )

        {

        session = static_cast<CMceSipSession*>(aClient->Implementation().SubSessions()[ count - 1 ]);

        }

    if ( session )

        {

        TMceIds ids = CMCETls::Storage()->iManagerIds;

        //receive

        aClient->ReceiveL( ids , RMessage2() );

        //client code

    	RDesReadStream readStream( *CMCETls::Storage()->iContextServer );

        CleanupClosePushL( readStream );

        CMceMsgObject<CMceComSession>* message = static_cast<CMceMsgObject<CMceComSession>*>

            (TMceComFactory().CreateL( (TMceItcDataType)ids.iMsgType,

                                                            readStream ) );

    	CleanupStack::PopAndDestroy(); // readStream

        CleanupStack::PushL( message );

        message->PushL();

        CleanupStack::PopAndDestroy( message );