/*

* 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 FILES

#include <e32base.h>

#include <e32std.h>

#include <sdporiginfield.h>

#include <sdpconnectionfield.h>

#include <sdpfmtattributefield.h>

#include <sdpmediafield.h>

#include <sdpattributefield.h>

#include <sdpcodecstringpool.h>

#include <sdpdocument.h>

#include <sdpbandwidthfield.h>

#include <siptoheader.h>

#include "mcemediadefs.h"

#include "mcesdpsession.h"

#include "mcecomsession.h"

#include "mcecommediastream.h"

#include "mcemediastream.h"

#include "mcesdpcodec.h"

#include "mcemediamanager.h"

#include "mcemediadefs.h"

#include "mcesrvlogs.h"

#include "mcemmlogs.h"

#include "mcepreconditions.h"

#include "mcemediaobserver.h"

#include "mcemediastate.h"

_LIT8(KTBCP, "TBCP"); 

// ================= MEMBER FUNCTIONS ==========================================

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

// CMceSdpSession::NewL

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

//

CMceSdpSession* CMceSdpSession::NewL( 

    CMceComSession& aSession,

    CMceMediaManager& aManager )

    {

    CMceSdpSession* self = NewLC( aSession, aManager );

    CleanupStack::Pop( self ); 

    return self;

    }

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

// CMceSdpSession::NewLC

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

 CMceSdpSession* CMceSdpSession::NewLC( 

    CMceComSession& aSession,

    CMceMediaManager& aManager )

    {

    CMceSdpSession* self = new ( ELeave ) CMceSdpSession( aSession, aManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CMceSdpSession::CMceSdpSession

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

//

CMceSdpSession::CMceSdpSession( 

    CMceComSession& aSession,

    CMceMediaManager& aManager )

    :       iManager( aManager ),

            iSessionId( 0 ),

            iSessionVersion( 0 ),

            iSession( &aSession ),

            iStringTable( NULL ),

            iOOldSchool( 0 ),

            iIOldSchool( 0 ),

            iOOldSchoolProceeding( 0 ),

            iOOldSchoolCompleted( 0 ),

            iIsMaster( ETrue ),

            iOldLocalMediaPort( 0 )

    {

    iSessionId = GetRandomNumber();

    iSessionVersion = GetRandomNumber();

    iIsSignallingRequired = KMceNoSignalling;

    }

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

// CMceSdpSession::ConstructL

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

void CMceSdpSession::ConstructL()

    {

    SetUserNameL(KMceSdpDefaultUserName);

    SetSessionNameL(KMceSdpDefaultSessionName);

    iStringPool = SdpCodecStringPool::StringPoolL();

    iStringTable = &SdpCodecStringPool::StringTableL(); 

    }

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

// CMceSdpSession::~CMceSdpSession

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

//   

CMceSdpSession::~CMceSdpSession()

    {

    delete iInitialSession;

    delete iSessionName;

    delete iUserName;

    delete iRemoteOrigin;

    iSdpRemoteMediaFields.ResetAndDestroy();

    if ( MediaSession() )

        {

        MediaSession()->DetachSDPSession();

        }

    if ( Backup() )

        {

        Backup()->DetachSDPSession();

        }

    }

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

// CMceSdpSession::Manager

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

//

CMceMediaManager& CMceSdpSession::Manager() const

    {

    return iManager;

    }

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

// CMceSdpSession::SignallingRequired

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

//

TInt& CMceSdpSession::SignallingRequired()

    {

    return iIsSignallingRequired;

    }

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

// CMceSdpSession::CreateOfferL

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

//

CSdpDocument* CMceSdpSession::CreateOfferL( 

    CMceComSession& aSession,

    CMceSdpSession::TOfferType aType )

    {

    MCEMM_DEBUG("CMceSdpSession::CreateOfferL(), Entry ")

    CSdpDocument* sdpDocument = NULL;

    if ( aType == CMceSdpSession::ERefresh )

        {

        User::LeaveIfNull( iSdpDocument );

        EncodeSessionParamsL( aSession, *iSdpDocument, aType );

        if(iOldLocalMediaPort != iSdpDocument->MediaFields()[0]->Port())

            {

            iSdpDocument->MediaFields()[0]->SetPortL( iOldLocalMediaPort );

            }

        return iSdpDocument;

        }

    if ( aType == CMceSdpSession::EFirst )

        {

        sdpDocument = CSdpDocument::NewLC();

        }

    else

        {

        sdpDocument = iSdpDocument;

        CleanSessionParams( *iSdpDocument );

        }

    EncodeSessionParamsL( aSession, *sdpDocument, aType );

    EncodeClientAttributesL( aSession, *sdpDocument );

    //create offer based on receive, receive only or send stream

    RPointerArray <CMceComMediaStream>& streams = aSession.Streams();

    RPointerArray< CSdpMediaField >& mediaLines = sdpDocument->MediaFields();

    CSdpMediaField* mediaLine = NULL;

    CMceSdpCodec* sdpCodec = NULL;

    CMceComMediaStream* mediastream = NULL;

    if ( aSession.iPullModeUpdate && aType == CMceSdpSession::EUpdate ) 

	    {

	    // matching the streams to media lines in Pull mode update case

	    MatchingStreamsToMLinesL( *sdpDocument, aSession );

	    }

    for ( TInt index = 0; index < streams.Count(); index++ )

        {

        mediastream = streams[ index ];

        TBool add = MediaLineLC( mediaLine, sdpCodec, mediastream,

                                 mediaLines, streams );

        if ( mediaLine )

        	{

            if (!add)

                {

                mediaLine->SetPortL( mediastream->iLocalMediaPort );

                }

            mediastream = mediastream->OfferStream();//downlink

            sdpCodec->PrepareForEncodeL( *mediastream, *mediaLine );

            sdpCodec->EncodeMediaOfferL( *mediastream, *mediaLine, *sdpDocument );

            if ( add )

                {

                mediaLines.AppendL( mediaLine );

                CleanupStack::Pop( mediaLine );

                mediastream->SdpIndex() = mediaLines.Count() - 1;

                }

            }

        }   

    User::LeaveIfError( sdpDocument->IsValid() );

    if ( aType == CMceSdpSession::EFirst )

        {

        CleanupStack::Pop( sdpDocument );

        }

    iOldLocalMediaPort = sdpDocument->MediaFields()[0]->Port();

    MCEMM_DEBUG("CMceSdpSession::CreateOfferL(), Exit ")

    return sdpDocument;

    }

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

// CMceSdpSession::MatchingStreamsAndMLinesL

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

//

void CMceSdpSession::MatchingStreamsToMLinesL( 

    CSdpDocument& aSdpDocument, 

    CMceComSession& aSession )

    {

    MCEMM_DEBUG("CMceSdpSession::MatchingStreamsToMLinesL(),entry ")

    //create offer based on receive, receive only or send stream

    RPointerArray <CMceComMediaStream>& streams = aSession.Streams();

    RPointerArray< CSdpMediaField >& mediaLines = aSdpDocument.MediaFields();

    // set SDPindex for stream if related meida line is found

    for ( TInt index = 0; index < streams.Count(); index++ )

        {

        CMceComMediaStream* mediastream = streams[ index ];

        CMceSdpCodec* sdpCodecStream = NULL;

        sdpCodecStream = Manager().SdpCodec( *mediastream );

        if ( sdpCodecStream )

          	{

          	TInt mediaIndex = 0;

            while( mediaIndex < mediaLines.Count() )

              	{

                CSdpMediaField* mediaLine = mediaLines[ mediaIndex ];

                CMceSdpCodec* sdpCodecMediaLine = NULL;

                sdpCodecMediaLine = Manager().SdpCodec( *mediaLine  );

                if ( sdpCodecMediaLine && sdpCodecMediaLine->Media() == sdpCodecStream->Media() )

                    {

                    mediastream->SdpIndex() = mediaIndex;

                    }  

                mediaIndex++;          

                }

          	}

        MCEMM_DEBUG_DVALUE( "CMceSdpSession::MatchingStreamsToMLinesL(), stream index:", index )

        MCEMM_DEBUG_DVALUE( "CMceSdpSession::MatchingStreamsToMLinesL(), stream SdpIndex:", 

            mediastream->SdpIndex() )

        }

    // set port to 0 if there are unused media lines

    for ( TInt index = 0; index < mediaLines.Count(); index++ )

        {

        // set old session media lines port to 0

        CSdpMediaField* mediaLine = mediaLines[ index ];

        TBool indexFoundFromStream = EFalse;

        TInt streamIndex = 0;

        while( !indexFoundFromStream && streamIndex < streams.Count() )

        	{

        	CMceComMediaStream* mediastream = streams[ streamIndex ];

        	if ( index == mediastream->SdpIndex() ) 

        		{

        		indexFoundFromStream = ETrue;

        		}

        	streamIndex++;

        	}

        if ( !indexFoundFromStream )

        	{

            MCEMM_DEBUG_DVALUE( "CMceSdpSession::MatchingStreamsToMLinesL(), \

    set media line to 0, index:", index )

        	mediaLine->SetPortL( 0 );  

        	}

        }

    MCEMM_DEBUG("CMceSdpSession::MatchingStreamsToMLinesL(),exit ")

    }

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

// CMceSdpSession::DecodeAnswerL

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

//

TInt CMceSdpSession::DecodeAnswerL( 

    CSdpDocument& aSdpDocument, 

    CMceComSession& aSession )                                

    {

    MCEMM_DEBUG("CMceSdpSession::DecodeAnswerL(), Entry ")

    iSdpDocument = &aSdpDocument;

    RPointerArray< CSdpMediaField >& mediaLines = iSdpDocument->MediaFields();

    if ( mediaLines.Count() == 0 )

        {

        User::Leave( KErrArgument );

        }

    // store the remote o= field

    StoreRemoteOriginL();

    // store the remote a= field

    StoreRemoteMediaFieldsL();

    TInt err = SetRemoteIpAddressL( aSession, aSdpDocument );

    if ( err != KErrNone )

        {

        MCEMM_DEBUG("ERROR: Incompatible network address")

        User::Leave( KErrArgument );

        }

    // handle media lines

    RPointerArray <CMceComMediaStream>& streams = aSession.Streams();

    CSdpMediaField* mediaLine = NULL;

    CMceSdpCodec* sdpCodec = NULL;

    CMceComMediaStream* mediastream = NULL;

    TInt index = 0;

	// Go through the answer's media lines. If there is a line for which there

	// is no stream (remote has put wrong port to answer), set port to zero.

	// Do this before the second for-loop, as DecodeMediaAnswerL may leave with

	// KMceErrOldSchool, starting old school hold. In that case any further

	// media lines would not be processed and if they had wrong port (non-zero

	// port but no media stream), we'd use that in our next offer.

	if ( !aSession.iPullModeUpdate )

		{

		for ( index = 0; index < mediaLines.Count(); index++ )

        	{

        	mediaLine = mediaLines[ index ];

			if ( Manager().SdpCodec( *mediaLine ) &&

				 !MediaSlotInUse( index, streams ) )

				{

				mediaLine->SetPortL( 0 );

				}

            }

        }

    for ( index = 0; index < mediaLines.Count(); index++ )

        {

        mediaLine = mediaLines[ index ];

        sdpCodec = Manager().SdpCodec( *mediaLine );

        if ( sdpCodec )

            {

            if ( !aSession.iPullModeUpdate )

                {

                TUint remotePort = mediaLine->Port();            

                aSession.iRemoteIpAddress.SetPort( remotePort );

                mediastream = MediaSlotInUse( index, streams );

                // Check for local Support of media and only decode media

        		// which we support or in use

				if ( mediastream )

					{

	                mediastream = mediastream->AnswerStream();//uplink

	                __ASSERT_ALWAYS( mediastream , User::Leave( KErrArgument ) );

	                mediastream->SetRemoteMediaPort( remotePort );

	                if ( remotePort )

	                    {

	                    TInt warnings = KErrNone;

	                    sdpCodec->PrepareForDecodeL( *mediaLine, mediastream );

	                    warnings = sdpCodec->DecodeMediaAnswerL( *mediaLine,

	                    										 *mediastream,

	                    										 aSdpDocument );

	                    if ( warnings  >= KMceSipBadRequest)

	                    	{

	                    	return warnings;

	                    	}

	                    mediastream->DecodedL( KMceRoleOfferer );

	                    }

	                else //rejected

	                    {

	                    mediastream->SetDirection( SdpCodecStringConstants::EAttributeInactive );

	                    mediastream->SdpIndex() = KErrNotFound;

	                    }

					}

                }

            else

                {

                DecodePullModeUpdateMediaLineL(

                    aSdpDocument, aSession, *mediaLine, index, *sdpCodec );

                }

            }

        else

            {

            MCEMM_DEBUG_SVALUE("No SDP codec. m-line", mediaLine->Media().DesC() )

            }

        }

    //check that all answers to offers were received        

    User::LeaveIfError( MediaSlotInUse( index, streams ) ? KErrArgument : KErrNone );

    // set the o= field with the local information

    EncodeSessionParamsL( aSession, *iSdpDocument );

    // store session level attributes

    DecodeClientAttributesL( aSdpDocument, aSession );

    MCEMM_DEBUG("CMceSdpSession::DecodeAnswerL(), Exit ")

    return KErrNone;

    }

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

// CMceSdpSession::DecodePullModeUpdateMediaLineL

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

//

void CMceSdpSession::DecodePullModeUpdateMediaLineL( 

    CSdpDocument& aSdpDocument, 

    CMceComSession& aSession,

    CSdpMediaField& aMediaLine,

    TInt aIndex,

    CMceSdpCodec& aSdpCodec ) 

    {

    MCEMM_DEBUG("CMceSdpSession::DecodePullModeUpdateMediaLineL(), Entry ")

    RPointerArray <CMceComMediaStream>& streams = aSession.Streams();

    CMceComMediaStream* mediastream = NULL;

    TUint remotePort = aMediaLine.Port();

    aSession.iRemoteIpAddress.SetPort( remotePort );

    // this media line might be from previous session, and it's

    // port is 0, if so mediastream can't be found

    mediastream = MediaSlotInUse( aIndex, streams );

    MCEMM_DEBUG_DVALUE( "CMceSdpSession::DecodePullModeUpdateMediaLineL, remotePort:", 

                         remotePort )

    if ( mediastream )

        {

        MCEMM_DEBUG("CMceSdpSession::DecodePullModeUpdateMediaLineL(), stream found ")

        mediastream = mediastream->AnswerStream();//uplink

        __ASSERT_ALWAYS( mediastream , User::Leave( KErrArgument ) );

        mediastream->SetRemoteMediaPort( remotePort ); 

        if ( remotePort )

            {

            aSdpCodec.PrepareForDecodeL( aMediaLine, mediastream );

            aSdpCodec.DecodeMediaAnswerL( aMediaLine, *mediastream, aSdpDocument );

            mediastream->DecodedL( KMceRoleOfferer );

            }

        else

            {

            mediastream->SetDirection( SdpCodecStringConstants::EAttributeInactive );

            mediastream->SdpIndex() = KErrNotFound;

            }

        }

    // if streams not found and port in meida line is not 0

    // leave with KErrNotFound       

    User::LeaveIfError( (!mediastream && remotePort) ? KErrNotFound : KErrNone );

    MCEMM_DEBUG("CMceSdpSession::DecodePullModeUpdateMediaLineL(), Exit ")

    }

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

// CMceSdpSession::DecodeOfferL

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

//

TInt CMceSdpSession::DecodeOfferL( 

    CSdpDocument& aSdpDocument, 

    CMceComSession& aSession )

    {

    MCEMM_DEBUG("CMceSdpSession::DecodeOfferL(), Entry ")

    TInt result = KErrNone;

    iSdpDocument = &aSdpDocument;

    RPointerArray <CSdpMediaField>& mediaLines = iSdpDocument->MediaFields();

    if ( mediaLines.Count() == 0 )

        {

        MCEMM_DEBUG("CMceSdpSession::DecodeOfferL(), ERROR: No media lines")

        MCEMM_DEBUG("CMceSdpSession::DecodeOfferL(), Exit ")

        return KMceSipWarnIncompatibleMediaFormat;

        }

    // store the remote o= field

    StoreRemoteOriginL();

    // store the remote a= field

    StoreRemoteMediaFieldsL();

    //set remote ip address

    result = SetRemoteIpAddressL( aSession, aSdpDocument );

    if ( result != KErrNone )

        {

        MCEMM_DEBUG("CMceSdpSession::DecodeOfferL(), ERROR: Incompatible network address")

        MCEMM_DEBUG("CMceSdpSession::DecodeOfferL(), Exit ")

        return result;

        }

    DecodeConnectionFieldL( *iSdpDocument, aSession );

    // handle media lines