/*

* 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 <badesca.h>

#include <mcesession.h>

#include <uri8.h>

#include <sdpcodecstringpool.h>

#include <SdpAttributeField.h>

#include <sdpdocument.h>

#include "mceclilogs.h"

#include "mcecomsession.h"

#include "mcecommediastream.h"

#include "mcesessionutility.h"

#include <SdpCodecStringPool.h>

#include <stringpool.h>

#include "mcecommediastream.h"

#include <mcertpsource.h>

#include <mcemsrpsource.h>

#include <sdpconnectionfield.h>

#include <sdpbandwidthfield.h>

#include <mcertpsource.h>

//# define _OPEN_SDPCODEC_STRINGPOOL  SdpCodecStringPool::OpenL()

#define _CLOSE_SDPCODEC_STRINGPOOL   SdpCodecStringPool::Close();

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

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

// TMceSessionUtility::getSessionSdPLineL

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

//

EXPORT_C HBufC8* TMceSessionUtility::getSessionSdPLineL(CMceSession* aSession, 

        TSDPLineName aSdpLineName)

    {

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

    // Ownership is tranferred to us for sessionLines

    CDesC8Array* sessionLines = static_cast<CDesC8Array*> (aSession->SessionSDPLinesL());

    if (sessionLines->MdcaCount() == 0)

        {

        MCECLI_DEBUG("TMceSessionUtility::getSessionSdPLineL: No session attributes set in the passed session \n");

        sessionLines->Reset();

        delete sessionLines;

        return NULL;

        }

    // Open SIP coec string pool

    TRAPD(error, SdpCodecStringPool::OpenL());

    if (error != KErrAlreadyExists && error != KErrNone)

        {

        delete sessionLines;

        User::Leave(error);

        }

    CSdpDocument* sdpDoc = NULL;

    CleanupStack::PushL(sessionLines);

    ConstructSdpDocumentL(sessionLines, sdpDoc); 

    CleanupStack::Pop(sessionLines);

    HBufC8* retValue = NULL;

    switch(aSdpLineName)

        {

        case EVersion:

            {

            TInt value = sdpDoc->SdpVersion();

            TBuf8<10> tmp;

            tmp.Num(value);

            retValue = tmp.AllocL();

            }

            break;

        case ESession:

            retValue = sdpDoc->SessionName().AllocL();

            break;

        case EInfo:

            retValue = sdpDoc->Info().AllocL();

            break;

        case EUri:

            {

            // Ownership will not be transferred to us so shouldn't delete the pointer

            CUri8* uri = sdpDoc->Uri();

            if (uri != NULL)

                {

                retValue = uri->Uri().UriDes().AllocL();

                }

            }

            break;

        case EZone:

            retValue = sdpDoc->ZoneAdjustments().AllocL();

            break;

        default:

            sessionLines->Reset();

            delete sessionLines;

            delete sdpDoc;

            _CLOSE_SDPCODEC_STRINGPOOL;

            User::Leave(KErrNotSupported);

        }

    sessionLines->Reset();

    delete sessionLines;

    delete sdpDoc;

    if (error == KErrNone)

        _CLOSE_SDPCODEC_STRINGPOOL;

    __ASSERT_ALWAYS(retValue!=NULL, User::Leave(KErrArgument));

    return retValue;

    }

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

// TMceSessionUtility::getRemoteMediaSDPAttrL

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

//

EXPORT_C HBufC8* TMceSessionUtility::getRemoteMediaSDPAttrL(CMceMediaStream* aStream,

                const TDesC8& aAttrName)

    {

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

    // Ownership is not transferred to us

    CMceSession* session = aStream->Session();

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

	if ( (session->State() >= CMceSession::ECancelling) || 

		(session->State() <= CMceSession::EIdle) )

        {

        MCECLI_DEBUG(" Session state shouldn't be idle Or shouldn't be either in cancelling, terminating , terminated  \n");

        User::Leave(KErrArgument);

        }

    CDesC8Array* mediaAttrs = NULL; 

    mediaAttrs = aStream->FlatData()->iRemoteMediaSDPLines;

    if (mediaAttrs == NULL || mediaAttrs->MdcaCount() == 0)

        {

        if (aStream->BoundStream())

			{

			mediaAttrs = aStream->BoundStreamL().FlatData()->iRemoteMediaSDPLines;		

			}

		}

	if (mediaAttrs == NULL || mediaAttrs->MdcaCount() == 0)

		{

		// Look for the another staream of same type to extract the remote media sdp attributes

        CMceMediaStream* tempStrm;

        for(TInt i=0; i<session->Streams().Count(); i++)

            {

            tempStrm = session->Streams()[i];

            if (tempStrm != aStream && (tempStrm->Type() == aStream->Type()) )

                {

                mediaAttrs = tempStrm->FlatData()->iRemoteMediaSDPLines;

                }

            }

        if (mediaAttrs == NULL || mediaAttrs->MdcaCount() == 0)

            {

            MCECLI_DEBUG("TMceSessionUtility::getRemoteMediaSDPAttrL: No Remote Media SDP attributes set to the streams \n");

            return NULL;

            }

        }

    //_OPEN_SDPCODEC_STRINGPOOL;

    TRAPD(error, SdpCodecStringPool::OpenL());

    if (error != KErrAlreadyExists && error != KErrNone)

        {

        User::Leave(error);

        }

    // If the attribute is found then the value will be in aValue.

    HBufC8* value = NULL;

    value = FindAttributeL(mediaAttrs, aAttrName);

    if (error == KErrNone)

        _CLOSE_SDPCODEC_STRINGPOOL;

    return value;

    }

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

// TMceSessionUtility::GetLocalConnectionAddrL

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

//

EXPORT_C void TMceSessionUtility::GetLocalConnectionAddrL(CMceSession* aSess, TInetAddr& aAddr)

    {

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

    aAddr = aSess->FlatData()->iLocalIpAddress;

    }

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

// TMceSessionUtility::GetRemoteConnectionAddrL

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

//

EXPORT_C HBufC8* TMceSessionUtility::GetRemoteConnectionAddrL(CMceMediaStream* aStream/*, TDesC8* hostAddr*/)

    {

    CMceSession* session = aStream->Session();

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

    if ( (session->State() >= CMceSession::ECancelling) || 

            (session->State() <= CMceSession::EIdle) )

        {

        MCECLI_DEBUG("TMceSessionUtility::GetRemoteConnectionAddrL: Session state shouldn't be idle Or shouldn't be either in cancelling, terminating , terminated");

        User::Leave(KErrArgument);

        }

    TBuf8<10> attrName;

    if (aStream->Type() == KMceMessage)

        {

        // Get the remote end's path attribute and extracts the host number from that

        //ownership willbe transferred to us so have to free up later

        HBufC8* pathValue = NULL;

        attrName.Zero();

        attrName.Copy(_L8("path"));

        pathValue = TMceSessionUtility::getRemoteMediaSDPAttrL(aStream, attrName);

        if (NULL!=pathValue)

            {

            TUriParser8 parser;

            TInt parseValue = parser.Parse(*pathValue); 

            MCECLI_DEBUG_DVALUE("\n CMceMessageSdpCodec::SetHostAddrPortFromPathAttr: Parsed return value for MSRP URI: ", 

                    parseValue);

            User::LeaveIfError(parseValue);

            //TBuf8<50> host = parser.Extract(EUriHost);

            HBufC8* hostAddr = parser.Extract(EUriHost).AllocL();

            delete pathValue;

            return hostAddr;

            }

        }

    // check if c line exists for the m-line correspands to this stream

    attrName.Zero();

    attrName.Copy(_L8("c"));

    HBufC8* hostAddr = NULL;

    hostAddr = TMceSessionUtility::getRemoteMediaSDPAttrL(aStream, attrName);

    if (hostAddr!=NULL)

        return hostAddr;

    else

        {

        TBuf<32> addr;

        session->FlatData()->iRemoteIpAddress.Output(addr);

        TBuf8<32> value;

        value.Copy(addr);

        return value.AllocL();

        }

    }

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

// TMceSessionUtility::GetLocalMediaPortL   

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

//

EXPORT_C void TMceSessionUtility::GetLocalMediaPortL(CMceMediaStream* aStream, TUint& aMediaPort )

    {

    MCECLI_DEBUG("TMceSessionUtility::GetLocalMediaPortL: Entry ");

    __ASSERT_ALWAYS(aStream!=NULL, User::Leave(KErrArgument));

	if ( (aStream->Session()->State() >= CMceSession::ECancelling) || 

			(aStream->Session()->State() <= CMceSession::EIdle) )

        {

        MCECLI_DEBUG("TMceSessionUtility::GetRemoteConnectionAddrL :  Session state shouldn't be idle Or shouldn't be either in cancelling, terminating , terminated");

        User::Leave(KErrArgument);

        }

	aMediaPort = aStream->FlatData()->LocalMediaPort();

	MCECLI_DEBUG_DVALUE("TMceSessionUtility::GetLocalMediaPortL : ", aMediaPort)

	MCECLI_DEBUG("TMceSessionUtility::GetLocalMediaPortL: Exit ");

    }

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

// TMceSessionUtility::GetRemoteMediaPortL

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

//

EXPORT_C void TMceSessionUtility::GetRemoteMediaPortL(CMceMediaStream* aStream, 

        TUint& aMediaPort )

    {

    MCECLI_DEBUG("TMceSessionUtility::GetRemoteMediaPortL: Entry ");

    __ASSERT_ALWAYS(aStream!=NULL, User::Leave(KErrArgument));

    CMceSession* session = aStream->Session();

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

    if ( (session->State() >= CMceSession::ECancelling) || 

            (session->State() <= CMceSession::EIdle) )

        {

        MCECLI_DEBUG("TMceSessionUtility::GetRemoteConnectionAddrL :  Session state shouldn't be idle Or shouldn't be either in cancelling, terminating , terminated");

        User::Leave(KErrArgument);

        }

    if (aStream->Type() == KMceMessage)

        {

        TBuf8<10> aAttrName(_L8("path"));

        // Get the remote end's path attribute and extracts the port number from that

        //ownership willbe transferred to us so have to free up later

        HBufC8* pathValue = NULL;

        pathValue = TMceSessionUtility::getRemoteMediaSDPAttrL(aStream, aAttrName);

        if (pathValue == NULL)

            {

            aMediaPort = aStream->FlatData()->RemoteMediaPort();

            return;

            }

        // 

        TUriParser8 parser;

        TInt parseValue = parser.Parse(pathValue->Des()); 

        MCECLI_DEBUG_DVALUE("\n CMceMsrpSource::SetHostAddrPortFromPathAttr: Parsed return value for MSRP URI: ",

                parseValue);

        TBuf8<10> portBuf = parser.Extract(EUriPort);

        TBuf16<10> portBuf16;

        portBuf16.Copy(portBuf);

        TLex iLex(portBuf16);

        iLex.Val(aMediaPort);  // returns the port value

        delete pathValue;

        return;

        }

    else

        {

        // Get send streams  and use remotemediaport

        if ( aStream->Source()->Type() == KMceRTPSource)

            {

            // find the send stream and get the remote media port

            if (aStream->BoundStream() && 

                    aStream->BoundStreamL().Source() != NULL &&

                    aStream->BoundStreamL().Source()->Type() != KMceRTPSource)

                {

                aMediaPort = aStream->BoundStreamL().FlatData()->RemoteMediaPort();

                return;

                }

            // if the streams are not binded then find the send stream aong the session streams

            for (TInt i=0; i<session->Streams().Count(); i++)

                {

                if (session->Streams()[i]!=NULL && (session->Streams()[i]!=aStream) &&

                        session->Streams()[i]->Type() == aStream->Type())

                    {

                    if (session->Streams()[i]->Source()->Type()!=KMceRTPSource)

                        {

                        aMediaPort = session->Streams()[i]->FlatData()->RemoteMediaPort();

                        return;

                        }

                    } // inside if

                } // For loop

            } // 

        }

    aMediaPort = aStream->FlatData()->RemoteMediaPort();

    MCECLI_DEBUG_DVALUE("TMceSessionUtility::GetRemoteMediaPortL : ", aMediaPort)

    MCECLI_DEBUG("TMceSessionUtility::GetRemoteMediaPortL: Exit ");

    }

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

// TMceSessionUtility::FindAttributeL

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

//

HBufC8* TMceSessionUtility::FindAttributeL(CDesC8Array* asdpLines , const TDesC8& aAttrName)

    {

    // Put all those session level names in single DesC8 object and pass that to CSdpDocument

    TBool attrFound = EFalse; 

    CSdpAttributeField* attr=NULL;

    RStringF searchAttr = SdpCodecStringPool::StringPoolL().OpenFStringL(aAttrName);

    HBufC8* retValue = NULL;

    for (TInt i=0; i< asdpLines->MdcaCount()&& !attrFound; i++)

        {

        TBuf8<200> attrText(asdpLines->MdcaPoint(i));

        // media attrivutes can also contain 'b' &'c' lines so skip them 

        _LIT8( KMceSdpConnectionLineMarker, "c=" );

        _LIT8( KMceSdpBandwidthLineMarker, "b=" );

        // Look for media specific conneciton(c= ) line

        if ( (attrText.Find(KMceSdpConnectionLineMarker) >= 0) )

            {

            if (attrText.Find(aAttrName) >= 0) 

                {

                // get the conneciton filed value 

                CSdpConnectionField* conn = NULL;

                TRAPD(err, conn = CSdpConnectionField::DecodeL(attrText));

                if (err != KErrNone)

                    {

                    searchAttr.Close();

                    _CLOSE_SDPCODEC_STRINGPOOL;

                    User::Leave(err);

                    }

                __ASSERT_ALWAYS(conn!=NULL, User::Leave(KErrArgument));

                retValue = conn->Address().Alloc();

                attrFound = ETrue;

                delete conn; // Free the memory for conn pointer

                }

            }

        // Look for media specific bandwidth(b= ) line

        else if ( (attrText.Find(KMceSdpBandwidthLineMarker) >= 0) )

            {

            if ((attrText.Find(aAttrName) >= 0))

                {

                // get the bandwidth filed and return the value

                CSdpBandwidthField* bandWidth = NULL;

                TRAPD(err, bandWidth = CSdpBandwidthField::DecodeL(attrText));

                if (err != KErrNone)

                    {

                    searchAttr.Close();

                    _CLOSE_SDPCODEC_STRINGPOOL;

                    User::Leave(err);

                    }

                __ASSERT_ALWAYS(bandWidth!=NULL, User::Leave(KErrArgument));

                TBuf8<20> value;

                value.Num(bandWidth->Value());

                retValue = value.Alloc();

                attrFound = ETrue;

                delete bandWidth;

                }

            }

        else

            // Look for media specific attribute(a= ) lines

            {

            // Have to free up later point of time

            TRAPD(err, attr = CSdpAttributeField::DecodeL(attrText));

            if (err != KErrNone)

                {

                searchAttr.Close();

                _CLOSE_SDPCODEC_STRINGPOOL;

                User::Leave(err);

                }

            if (attr == NULL)

                {

                MCECLI_DEBUG("TMceSessionUtility::FindAttributeL: Error in decoding the media attribute : ");

                searchAttr.Close();

                _CLOSE_SDPCODEC_STRINGPOOL;

                User::Leave(KErrArgument);

                }

            if (attr->Attribute() ==  searchAttr && !attrFound)

                {

                retValue = attr->Value().Alloc();

                attrFound = ETrue;

                }

            delete attr;

            }

        }

    if (attrFound == EFalse)

        {

        retValue = NULL;

        }

    searchAttr.Close();

    return retValue;

    }

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

// TMceSessionUtility::ConstructSdpDocumentL

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

//

void TMceSessionUtility::ConstructSdpDocumentL(CDesC8Array* asdpLines, CSdpDocument*& asdpDoc)

    {

    if (asdpDoc)

        {

        delete asdpDoc;

        asdpDoc = NULL;

        }

    TBuf8<1000> text; 

    for(TInt i=0; i<asdpLines->MdcaCount(); i++)

        {

        TBuf8<200> temp(asdpLines->MdcaPoint(i));

        text.Append( temp );

        }

    TInt leaveValue = KErrNone;

    // Ownership for sdpDoc is tranferred to us.. 

    TRAP(leaveValue, asdpDoc = CSdpDocument::DecodeL(text));

    if (leaveValue != KErrNone)

        {

        MCECLI_DEBUG_DVALUE("TMceSessionUtility::ConstructSdpDocument: Error in decoding the SdpDocument text : %d", leaveValue);

        SdpCodecStringPool::Close();

        User::Leave(leaveValue);

        }    

    }