/*

* 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 "mcepreconditions.h"

#include "sdpdocument.h"

#include "sdpmediafield.h"

#include "sdpattributefield.h"

#include "sdpfmtattributefield.h"

#include "mcesip.h"

#include "sdpcodecstringpool.h"

#include "sdpcodecstringconstants.h"

#include "mcemmlogs.h"

#include "mcemediastate.h"

#define SDP_STRING( stringIndex )\

    iStringPool.StringF( stringIndex, *iStringTable )

const TInt KCurrPrecType = 0;

const TInt KCurrPrecStatusType = 1;

const TInt KCurrPrecDirection = 2;

const TInt KDesPrecType = 0;

const TInt KDesPrecStrength = 1;

const TInt KDesPrecStatusType = 2;

const TInt KDesPrecDirection = 3;

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

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

// TMcePreconditions::TMcePreconditions

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

//

TMcePreconditions::TMcePreconditions( CMceComMediaStream& aStream )

    : iStream( aStream ),

      iState( ECreated ),

      iStringTable ( 0 ),

      iType ( EQosPreconds )

    {

    }

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

// TMcePreconditions::~TMcePreconditions

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

// 

TMcePreconditions::~TMcePreconditions()

    {

    }

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

// TMcePreconditions::ConstrucL

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

//

void TMcePreconditions::ConstructL()

    {

    iStringPool = SdpCodecStringPool::StringPoolL();

    iStringTable = &SdpCodecStringPool::StringTableL();

    iKAttributeCurr = SDP_STRING( SdpCodecStringConstants::EAttributeCurr );

    iKAttributeDes  = SDP_STRING( SdpCodecStringConstants::EAttributeDes );

    iKAttributeConf = SDP_STRING( SdpCodecStringConstants::EAttributeConf );

    iKAttributeNone = SDP_STRING( SdpCodecStringConstants::EAttributeStatusDirectionTagNone );

    iKAttributeSend = SDP_STRING( SdpCodecStringConstants::EAttributeStatusDirectionTagSend );

    iKAttributeRecv = SDP_STRING( SdpCodecStringConstants::EAttributeStatusDirectionTagRecv );

    iKAttributeSendRecv = SDP_STRING( SdpCodecStringConstants::EAttributeStatusDirectionTagSendrecv );

    iKAttributeLocal = SDP_STRING( SdpCodecStringConstants::EAttributeStatusTypeLocal );

    iKAttributeRemote = SDP_STRING( SdpCodecStringConstants::EAttributeStatusTypeRemote );

    iKAttributeMandatory = SDP_STRING( SdpCodecStringConstants::EAttributeStatusStrengthTagMandatory );

    iKAttributeOptional = SDP_STRING( SdpCodecStringConstants::EAttributeStatusStrengthTagOptional );

    iKAttributeFailure = SDP_STRING( SdpCodecStringConstants::EAttributeStatusStrengthTagFailure );

    iKAttributeUnknown = SDP_STRING( SdpCodecStringConstants::EAttributeStatusStrengthTagUnknown );

	iKAttributeEnd2End = SDP_STRING( SdpCodecStringConstants::EAttributeStatusTypeE2e );

    DoConstructL();

    }

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

// TMcePreconditions::IsMet

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

//

TBool TMcePreconditions::IsMet() const

    {

    return iState == EReserved;

    }

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

// TMcePreconditions::IsMet

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

//

TMcePreconditions::TPreconditionType TMcePreconditions::Type()

	{

	return iType;

	}

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

// TMcePreconditions::ConstrucL

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

//

void TMcePreconditions::ConstrucL( const TMcePreconditions& aPreconditions )

    {

    __ASSERT_ALWAYS( aPreconditions.iStringTable != NULL, 

                     User::Leave( KErrArgument ) );

    iState = aPreconditions.iState;

    iStringPool = aPreconditions.iStringPool;

    iStringTable = aPreconditions.iStringTable;

    iKAttributeCurr = aPreconditions.iKAttributeCurr;

    iKAttributeDes = aPreconditions.iKAttributeDes;

    iKAttributeConf = aPreconditions.iKAttributeConf;

    iKAttributeNone = aPreconditions.iKAttributeNone;

    iKAttributeSend = aPreconditions.iKAttributeSend;

    iKAttributeRecv = aPreconditions.iKAttributeRecv;

    iKAttributeSendRecv = aPreconditions.iKAttributeSendRecv;

    iKAttributeLocal = aPreconditions.iKAttributeLocal;

    iKAttributeRemote = aPreconditions.iKAttributeRemote;

    iKAttributeMandatory = aPreconditions.iKAttributeMandatory;

    iKAttributeOptional = aPreconditions.iKAttributeOptional;

    iKAttributeFailure = aPreconditions.iKAttributeFailure;

    iKAttributeUnknown = aPreconditions.iKAttributeUnknown;

    iKAttributeEnd2End = aPreconditions.iKAttributeEnd2End;   

    }

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

// TMceSegmentedPreconditions::TMceSegmentedPreconditions

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

//

TMceSegmentedPreconditions::TMceSegmentedPreconditions( 

    CMceComMediaStream& aStream )

    : TMcePreconditions( aStream )

    {

    }  

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

// TMceSegmentedPreconditions::CloneL

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

//

TMcePreconditions* TMceSegmentedPreconditions::CloneL( 

    CMceComMediaStream& aStream )

    {

    TMceSegmentedPreconditions* copy = 

        new (ELeave) TMceSegmentedPreconditions( aStream );

    CleanupStack::PushL( copy );

    copy->ConstrucL( *this );

    CleanupStack::Pop( copy );

    return copy;

    }

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

// TMceSegmentedPreconditions::ConstrucL

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

//

void TMceSegmentedPreconditions::ConstrucL( 

    const TMceSegmentedPreconditions& aPreconditions )

    {

    TMcePreconditions::ConstrucL( aPreconditions );

    iCurrentLocalStatus = aPreconditions.iCurrentLocalStatus;

    iCurrentRemoteStatus = aPreconditions.iCurrentRemoteStatus;

    iDesiredLocalSend = aPreconditions.iDesiredLocalSend;

    iDesiredLocalRecv = aPreconditions.iDesiredLocalRecv;

    iDesiredRemoteSend = aPreconditions.iDesiredRemoteSend;

    iDesiredRemoteRecv = aPreconditions.iDesiredRemoteRecv;

    iConfirmation = aPreconditions.iConfirmation;

    iType  = aPreconditions.iType;

    }

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

// TMceSegmentedPreconditions::DoConstructL

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

//

void TMceSegmentedPreconditions::DoConstructL()

    {

    MCEMM_DEBUG("TMceSegmentedPreconditions::DoConstructL(), Entry ")

    iCurrentLocalStatus = iKAttributeNone;

    iCurrentRemoteStatus = iKAttributeNone;

    iDesiredLocalSend = iKAttributeNone;

    iDesiredLocalRecv = iKAttributeNone;

    iDesiredRemoteSend = iKAttributeNone;

    iDesiredRemoteRecv = iKAttributeNone;

    iConfirmation = iKAttributeNone;

    iType = TMcePreconditions::EQosPreconds;

    TInt direction = iStream.Direction();

    direction = direction == SdpCodecStringConstants::EAttributeInactive ? 

                iStream.SdpStreamType() : direction;

    switch( direction )

        {

        case SdpCodecStringConstants::EAttributeSendrecv:

            {

            SetDesiredStatus( iKAttributeLocal, iKAttributeSendRecv, iKAttributeMandatory );

            MCEMM_DEBUG_SVALUE("desired direction ", iKAttributeSendRecv.DesC() )

            break;

            }

        case SdpCodecStringConstants::EAttributeSendonly:

            {

            SetDesiredStatus( iKAttributeLocal, iKAttributeSend, iKAttributeMandatory );

            MCEMM_DEBUG_SVALUE("desired direction ", iKAttributeSend.DesC() )

            break;

            }

        case SdpCodecStringConstants::EAttributeRecvonly:

            {

            SetDesiredStatus( iKAttributeLocal, iKAttributeRecv, iKAttributeMandatory );

            MCEMM_DEBUG_SVALUE("desired direction ", iKAttributeRecv.DesC() )

            break;

            }

        default:

            {

            User::Leave( KErrArgument );

            }

        }

    MCEMM_DEBUG("TMceSegmentedPreconditions::DoConstructL(), Exit ")        

    }

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

// TMceSegmentedPreconditions::EncodeL

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

//

void TMceSegmentedPreconditions::EncodeL( CSdpMediaField& aMedia )

    {

    MCEMM_DEBUG("TMceSegmentedPreconditions::EncodeL(), Entry ")

    TMceNegotiationRole role = iStream.Session()->NegotiationState().Role();

    //if it is MT but does not decoded anything then we should not add in 183

	if ( role == EMceRoleAnswerer && iState == ECreated && 

		iStream.PreconditionsL( KMceSecPreconditions ) )

		{

		return;

		}

    //currentLocalStatus

    EncodeCurrentStatusL( aMedia, iKAttributeLocal );

    //currentRemoteStatus

    EncodeCurrentStatusL( aMedia, iKAttributeRemote );

    //desiredLocalStatus

    EncodeDesiredStatusL( aMedia, iKAttributeLocal );

    //desiredRemoteStatus

    EncodeDesiredStatusL( aMedia, iKAttributeRemote );

    //if answerer and confirmation is needed based on offerer's 

    //reservation status

    if ( role == EMceRoleAnswerer && RemoteReservationNeeded() )

        {

        iConfirmation = DesiredDirection( iKAttributeRemote );

        EncodeConfirmationL( aMedia );

        }

    if ( role == EMceRoleOfferer )

        {

        if ( iConfirmation != iKAttributeNone )

            {

            iState = EReserved;

            iConfirmation = iKAttributeNone;

            }

        else

            {

            iState = ENegotiating;

            }

        }

    else

        {

        //reset confirmation

    	iConfirmation = iKAttributeNone;

    	//if not allready e2e reserved

    	if ( !IsMet() )

        	{

        	SetState();

        	}

        }   

    MCEMM_DEBUG("TMceSegmentedPreconditions::EncodeL(), Exit ") 

    }

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

// TMceSegmentedPreconditions::DecodeL

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

//

TMceSipWarningCode TMceSegmentedPreconditions::DecodeL( CSdpMediaField& aMedia )

    {

    MCEMM_DEBUG("TMceSegmentedPreconditions::DecodeL(), Entry ")

    TMceNegotiationRole role = iStream.Session()->NegotiationState().Role();

    RPointerArray<CSdpAttributeField>& attributes = aMedia.AttributeFields();

    TInt decoded = 0;

    TInt index = 0;

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

        {

        CSdpAttributeField* attribute = attributes[ index ];

        //if offerer and there is confirmation request

        if ( attribute->Attribute() == iKAttributeConf && 

             role == EMceRoleOfferer )

            {

            decoded += DecodeConfStatusL( *attribute );

            }

        //current and desired statuses are only decoded when reservation

        //is still ongoing

        else if ( !IsMet() )

            {

            //decode current status

            if ( attribute->Attribute() == iKAttributeCurr )

                {

                decoded += DecodeCurrentStatusL( *attribute );

                }

            //decode desired status

            else if ( attribute->Attribute() == iKAttributeDes )

                {

                decoded += DecodeDesiredStatusL( *attribute );

                }

            else

                {

                //NOP

                }

            }

        else

            {

            //NOP

            }

        }

    //if something was decoeded

    if ( decoded )

        {

        SetState();

        }

    else	

        {

        //if nothing was decoded. For example preconditions were sent

        //but nothing received. This is interpretet as resources are reserved

        iState = EReserved;

        iCurrentRemoteStatus = DesiredDirection( iKAttributeRemote );

        iCurrentRemoteStatus = ( iCurrentRemoteStatus == iKAttributeNone ) ?

            DecodeMediaDirectionL( DesiredDirection( iKAttributeLocal ).DesC() ) : 

            iCurrentRemoteStatus;

        }

    MCEMM_DEBUG("TMceSegmentedPreconditions::DecodeL(), Exit ")

    return KErrNone;

    }

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

// TMceSegmentedPreconditions::EncodeCurrentStatusL

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

//

void TMceSegmentedPreconditions::EncodeCurrentStatusL( 

    CSdpMediaField& aMedia,

    RStringF aAccessNetwork ) const

    {

    MCEMM_DEBUG("TMceSegmentedPreconditions::EncodeCurrentStatusL(), Entry ")

    MCEMM_DEBUG_SVALUE("access network", aAccessNetwork.DesC() )

    HBufC8* currentStatus = NULL;

    CSdpAttributeField* qosLine = NULL;

    RStringF current = aAccessNetwork == iKAttributeLocal ? 

                       iCurrentLocalStatus : iCurrentRemoteStatus;

    RPointerArray<CSdpAttributeField>& attributes = aMedia.AttributeFields();

    currentStatus = CurrentStausTextLC( aAccessNetwork.DesC(),

                                        current.DesC() );

    qosLine = CSdpAttributeField::NewLC( iKAttributeCurr, *currentStatus );

    MCEMM_DEBUG_SVALUE("encoded current status", qosLine->Value() )

    attributes.AppendL( qosLine );

    CleanupStack::Pop( qosLine );

    CleanupStack::PopAndDestroy( currentStatus );

    MCEMM_DEBUG("TMceSegmentedPreconditions::EncodeCurrentStatusL(), Exit ")

    }

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

// TMceSegmentedPreconditions::EncodeDesiredStatusL

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

//

void TMceSegmentedPreconditions::EncodeDesiredStatusL( 

    CSdpMediaField& aMedia,

    RStringF aAccessNetwork ) const

    {

    MCEMM_DEBUG("TMceSegmentedPreconditions::EncodeDesiredStatusL(), Entry ")

    MCEMM_DEBUG_SVALUE("access network", aAccessNetwork.DesC() )

    HBufC8* desiredStatus = NULL;

    CSdpAttributeField* qosLine = NULL;

    RStringF desiredSend = aAccessNetwork == iKAttributeLocal ? 

                           iDesiredLocalSend : iDesiredRemoteSend;

    RStringF desiredRecv = aAccessNetwork == iKAttributeLocal ? 

                           iDesiredLocalRecv : iDesiredRemoteRecv;

    RPointerArray<CSdpAttributeField>& attributes = aMedia.AttributeFields();

    if ( desiredSend == desiredRecv )

        {

        desiredStatus = DesiredStausTextLC( desiredSend.DesC(),

                                            aAccessNetwork.DesC(),

                                            iKAttributeSendRecv.DesC() );

        qosLine = CSdpAttributeField::NewLC( iKAttributeDes, *desiredStatus );

        MCEMM_DEBUG_SVALUE("encoded desired send & recv status", qosLine->Value() )

        attributes.AppendL( qosLine );

        CleanupStack::Pop( qosLine );

        CleanupStack::PopAndDestroy( desiredStatus );

        }

    else

        {

        desiredStatus = DesiredStausTextLC( desiredSend.DesC(),

                                            aAccessNetwork.DesC(),

                                            iKAttributeSend.DesC() );

        qosLine = CSdpAttributeField::NewLC( iKAttributeDes, *desiredStatus );

        MCEMM_DEBUG_SVALUE("encoded desired send status", qosLine->Value() )

        attributes.AppendL( qosLine );

        CleanupStack::Pop( qosLine );

        CleanupStack::PopAndDestroy( desiredStatus );

        desiredStatus = DesiredStausTextLC( desiredRecv.DesC(),

                                            aAccessNetwork.DesC(),

                                            iKAttributeRecv.DesC() );

        qosLine = CSdpAttributeField::NewLC( iKAttributeDes, *desiredStatus );

        MCEMM_DEBUG_SVALUE("encoded desired recv status", qosLine->Value() )

        attributes.AppendL( qosLine );

        CleanupStack::Pop( qosLine );

        CleanupStack::PopAndDestroy( desiredStatus );   

        }

    MCEMM_DEBUG("TMceSegmentedPreconditions::EncodeDesiredStatusL(), Exit ")

    }

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

// TMceSegmentedPreconditions::EncodeConfirmationL

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

//

void TMceSegmentedPreconditions::EncodeConfirmationL( CSdpMediaField& aMedia )

    {

    MCEMM_DEBUG("TMceSegmentedPreconditions::EncodeConfirmationL(), Entry ")

    if ( iConfirmation != iKAttributeNone )

        {

        HBufC8* confirmation = NULL;

        CSdpAttributeField* qosLine = NULL;

        RPointerArray<CSdpAttributeField>& attributes = aMedia.AttributeFields();

        confirmation = CurrentStausTextLC( iKAttributeRemote.DesC(),

                                           iConfirmation.DesC() );

        qosLine = CSdpAttributeField::NewLC( iKAttributeConf, *confirmation );

        MCEMM_DEBUG_SVALUE("encoded confirmation status", qosLine->Value() )

        attributes.AppendL( qosLine );

        CleanupStack::Pop( qosLine );

        CleanupStack::PopAndDestroy( confirmation );

        }

    MCEMM_DEBUG("TMceSegmentedPreconditions::EncodeConfirmationL(), Exit ")   

    }

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

// TMceSegmentedPreconditions::DecodeCurrentStatusL

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

//

TUint TMceSegmentedPreconditions::DecodeCurrentStatusL( 

    CSdpAttributeField& aAttribute )

    {

    MCEMM_DEBUG("TMceSegmentedPreconditions::DecodeCurrentStatusL(), Entry ")

    TUint decoded = (TUint)ETrue;

    TPtrC8 accessNetworkDesc;

    TPtrC8 directionDesc;

    if ( ParseCurrentStatus( aAttribute.Value(), accessNetworkDesc, directionDesc ) == KErrNone )

        {

        if ( accessNetworkDesc == iKAttributeLocal.DesC() )

            {

            SetRemoteStatus( DecodeMediaDirectionL( directionDesc ) );

            MCEMM_DEBUG_SVALUE("decoded current status", aAttribute.Value() )

            }

        }

    else

        {

        decoded = (TUint)EFalse;

        }

    MCEMM_DEBUG("TMceSegmentedPreconditions::DecodeCurrentStatusL(), Exit ")

    return decoded;

    }

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

// TMceSegmentedPreconditions::DecodeDesiredStatusL

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

//

TUint TMceSegmentedPreconditions::DecodeDesiredStatusL( 

    CSdpAttributeField& aAttribute )

    {