/*
* Copyright (c) 2008 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 <e32base.h>
#include <e32debug.h>
#include <e32cons.h>
#include <badesca.h>
#include <sdpdocument.h>
#include <sdporiginfield.h>
#include <sdpconnectionfield.h>
#include <sdpmediafield.h>
#include "nspplugin.h"
#include "nsptestconsolesession.h"
#include "nsptestasyncservice.h"
#include "nsptestconsolecenrep.h"
#include "nsptestconsolestream.h"

#define __PANIC( aError ) User::Panic( _L( "NSP Test console session" ), aError )
#define PTR_DEL( aPtr ) delete aPtr; aPtr = NULL

_LIT8( KOriginField, "o=alice 2890844526 2890844527 IN IP4 131.117.0.4\r\n" );
_LIT8( KConnFieldLocal, "c=IN IP4 10.0.0.6\r\n" );
_LIT8( KConnFieldRemote, "c=IN IP4 192.168.0.6\r\n" );
_LIT8( KAudioMedia, "m=audio 2330 RTP/AVP 96\r\n" );

const TUint KProtocolUdp = 2;

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::NewL
// -----------------------------------------------------------------------------
// 
CNSPTestConsoleSession* CNSPTestConsoleSession::NewL(
		CNSPPlugin& aApi, CRepository& aCenrep, MAsyncService& aAsync )
    {
    CNSPTestConsoleSession* self = new ( ELeave ) CNSPTestConsoleSession( aApi, aAsync );
    CleanupStack::PushL( self );
    self->ConstructL( aCenrep );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::NewLC
// -----------------------------------------------------------------------------
// 
CNSPTestConsoleSession* CNSPTestConsoleSession::NewLC(
		CNSPPlugin& aApi, CRepository& aCenrep, MAsyncService& aAsync )
    {
    CNSPTestConsoleSession* self = new ( ELeave ) CNSPTestConsoleSession( aApi, aAsync );
    CleanupStack::PushL( self );
    self->ConstructL( aCenrep );
    return self;
    }

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::CNSPTestConsoleSession
// -----------------------------------------------------------------------------
// 
CNSPTestConsoleSession::CNSPTestConsoleSession( CNSPPlugin& aApi, MAsyncService& aAsync )
	: iApi( aApi ),
	  iAsync( aAsync )
	{
    }

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::ConstructL
// -----------------------------------------------------------------------------
// 
void CNSPTestConsoleSession::ConstructL( CRepository& aCenrep )
    {
    TUint32 iap;
    TBuf8<255> buffer;
	TCenrepReader reader( aCenrep );
	
	reader.ReadIapL( iap );
	reader.ReadDomainL( buffer );
	
	iSessionId = iApi.NewSessionL( *this, iap, buffer, KProtocolUdp );
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::~CNSPTestConsoleSession
// -----------------------------------------------------------------------------
// 
CNSPTestConsoleSession::~CNSPTestConsoleSession()
    {
    TRAP_IGNORE( iApi.CloseSessionL( iSessionId ) );
    PTR_DEL( iOffer );
    PTR_DEL( iAnswer );
    PTR_DEL( iOutStream );
    PTR_DEL( iInStream );
    }

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::Initialized
// -----------------------------------------------------------------------------
// 
void CNSPTestConsoleSession::Initialized( TUint aSessionId )
	{
	__ASSERT_ALWAYS( aSessionId == iSessionId, __PANIC( KErrTotalLossOfPrecision ) );
	iState = ( EInitializing == iState ? EIdle :
				(TSessionState) KErrTotalLossOfPrecision );
	__ASSERT_ALWAYS( iState > 0,  __PANIC( KErrTotalLossOfPrecision ) );
	iAsync.Stop();
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::OfferReady
// -----------------------------------------------------------------------------
// 
void CNSPTestConsoleSession::OfferReady( TUint aSessionId, CSdpDocument* aOffer )
	{
	__ASSERT_ALWAYS( aSessionId == iSessionId, __PANIC( KErrTotalLossOfPrecision ) );
	iState = ( ECreateOffer == iState ? EIdle :
				( EDecodeOffer == iState ? EIdle :
					(TSessionState) KErrTotalLossOfPrecision ) );
	StoreOffer( aOffer );
	iAsync.Stop();
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::AnswerReady
// -----------------------------------------------------------------------------
// 
void CNSPTestConsoleSession::AnswerReady( TUint aSessionId, CSdpDocument* aAnswer )
	{
	__ASSERT_ALWAYS( aSessionId == iSessionId, __PANIC( KErrTotalLossOfPrecision ) );
	iState = ( ECreateAnswer == iState ? EDecodeOffer :
				( EDecodeAnswer == iState ? EIdle :
					(TSessionState) KErrTotalLossOfPrecision ) );
	StoreAnswer( aAnswer );
	iAsync.Stop();
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::UpdateSdp
// -----------------------------------------------------------------------------
// 
void CNSPTestConsoleSession::UpdateSdp( TUint aSessionId, CSdpDocument* aOffer )
	{
	__ASSERT_ALWAYS( aSessionId == iSessionId, __PANIC( KErrTotalLossOfPrecision ) );
	iState = ( EIdle == iState ? EUpdating :
				(TSessionState) KErrTotalLossOfPrecision );
	StoreOffer( aOffer );
	iAsync.Stop();
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::ErrorOccurred
// -----------------------------------------------------------------------------
// 
void CNSPTestConsoleSession::ErrorOccurred( TUint aSessionId, TInt aError )
	{
	__ASSERT_ALWAYS( aSessionId == iSessionId, __PANIC( KErrTotalLossOfPrecision ) );
	iState = (TSessionState) aError;
	iAsync.Stop();
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::IcmpErrorOccurred
// -----------------------------------------------------------------------------
// 
void CNSPTestConsoleSession::IcmpErrorOccurred( TUint aSessionId, TInt aError )
	{
	__ASSERT_ALWAYS( aSessionId == iSessionId, __PANIC( KErrTotalLossOfPrecision ) );
	iState = (TSessionState) aError;
	iAsync.Stop();
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::CreateOfferL
// -----------------------------------------------------------------------------
// 
TInt CNSPTestConsoleSession::CreateOfferL( CTestConsoleStream& aOutStream )
	{
	__ASSERT_ALWAYS( &aOutStream, User::Leave( KErrArgument ) );
	__ASSERT_ALWAYS( EIdle == iState, User::Leave( KErrTotalLossOfPrecision ) );
	iState = ECreateOffer;
	
	delete iOffer;
	iOffer = CSdpDocument::NewL();
	iOffer->SetConnectionField( CSdpConnectionField::DecodeL( KConnFieldLocal() ) );
	iOffer->SetOriginField( CSdpOriginField::DecodeL( KOriginField() ) );
	CSdpMediaField* mediafield = CSdpMediaField::DecodeLC( KAudioMedia() );
	iOffer->MediaFields().AppendL( mediafield );
	CleanupStack::Pop( mediafield );
	aOutStream.EncodeL( *mediafield );
	
	return iApi.CreateOfferL( iSessionId, iOffer );
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::ResolveL
// -----------------------------------------------------------------------------
// 
TInt CNSPTestConsoleSession::ResolveL(
		CTestConsoleStream& aInStream, CTestConsoleStream& aOutStream )
	{
	__ASSERT_ALWAYS( &aInStream, User::Leave( KErrArgument ) );
	__ASSERT_ALWAYS( &aOutStream, User::Leave( KErrArgument ) );
	__ASSERT_ALWAYS( EIdle == iState, User::Leave( KErrTotalLossOfPrecision ) );
	iState = ECreateAnswer;
	
	CSdpMediaField* mediafield = NULL;
	
	delete iOffer;
	iOffer = CSdpDocument::NewL();
	iOffer->SetConnectionField( CSdpConnectionField::DecodeL( KConnFieldRemote() ) );
	iOffer->SetOriginField( CSdpOriginField::DecodeL( KOriginField() ) );
	mediafield = CSdpMediaField::DecodeLC( KAudioMedia() );
	iOffer->MediaFields().AppendL( mediafield );
	CleanupStack::Pop( mediafield );
	aInStream.DecodeL( *mediafield );
	
	delete iAnswer;
	iAnswer = CSdpDocument::NewL();
	iAnswer->SetConnectionField( CSdpConnectionField::DecodeL( KConnFieldLocal() ) );
	iAnswer->SetOriginField( CSdpOriginField::DecodeL( KOriginField() ) );
	mediafield = CSdpMediaField::DecodeLC( KAudioMedia() );
	iAnswer->MediaFields().AppendL( mediafield );
	CleanupStack::Pop( mediafield );
	aOutStream.EncodeL( *mediafield );
	
	return iApi.ResolveL( iSessionId, iOffer, iAnswer );
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::DecodeAnswerL
// -----------------------------------------------------------------------------
// 
TInt CNSPTestConsoleSession::DecodeAnswerL( CTestConsoleStream& aInStream )
	{
	__ASSERT_ALWAYS( &aInStream, User::Leave( KErrArgument ) );
	__ASSERT_ALWAYS( EIdle == iState, User::Leave( KErrTotalLossOfPrecision ) );
	iState = EDecodeAnswer;
	
	delete iAnswer;
	iAnswer = CSdpDocument::NewL();
	iAnswer->SetConnectionField( CSdpConnectionField::DecodeL( KConnFieldRemote() ) );
	iAnswer->SetOriginField( CSdpOriginField::DecodeL( KOriginField() ) );
	CSdpMediaField* mediafield = CSdpMediaField::DecodeLC( KAudioMedia() );
	iAnswer->MediaFields().AppendL( mediafield );
	CleanupStack::Pop( mediafield );
	aInStream.DecodeL( *mediafield );
	
	return iApi.DecodeAnswerL( iSessionId, iAnswer );
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::UpdateL
// -----------------------------------------------------------------------------
// 
void CNSPTestConsoleSession::UpdateL( CTestConsoleStream& aInStream )
	{
	__ASSERT_ALWAYS( &aInStream, User::Leave( KErrArgument ) );
	
	delete iOffer;
	iOffer = CSdpDocument::NewL();
	iOffer->SetConnectionField( CSdpConnectionField::DecodeL( KConnFieldRemote() ) );
	iOffer->SetOriginField( CSdpOriginField::DecodeL( KOriginField() ) );
	CSdpMediaField* mediafield = CSdpMediaField::DecodeLC( KAudioMedia() );
	iOffer->MediaFields().AppendL( mediafield );
	CleanupStack::Pop( mediafield );
	aInStream.DecodeL( *mediafield );
	
	iApi.UpdateL( iSessionId, iOffer );
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::State
// -----------------------------------------------------------------------------
// 
CNSPTestConsoleSession::TSessionState CNSPTestConsoleSession::State() const
	{
	return iState;
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::StoreOutStream
// -----------------------------------------------------------------------------
// 
void CNSPTestConsoleSession::StoreOutStream( CTestConsoleStream* aOutStream )
	{
	if ( iOutStream != aOutStream )
		{
		delete iOutStream;
		iOutStream = aOutStream;
		}
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::StoreInStream
// -----------------------------------------------------------------------------
// 
void CNSPTestConsoleSession::StoreInStream( CTestConsoleStream* aInStream )
	{
	if ( iInStream != aInStream )
		{
		delete iInStream;
		iInStream = aInStream;
		}
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::StoreOffer
// -----------------------------------------------------------------------------
// 
void CNSPTestConsoleSession::StoreOffer( CSdpDocument* aOffer )
	{
	if ( iOffer != aOffer )
		{
		delete iOffer;
		iOffer = aOffer;
		}
	}

// -----------------------------------------------------------------------------
// CNSPTestConsoleSession::StoreAnswer
// -----------------------------------------------------------------------------
// 
void CNSPTestConsoleSession::StoreAnswer( CSdpDocument* aAnswer )
	{
	if ( iAnswer != aAnswer )
		{
		delete iAnswer;
		iAnswer = aAnswer;
		}
	}