/*

* Copyright (c) 2009-2010 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:

* MSRP Implementation

*

*/

//  Include Files

#include "CMSRPSessionImplementation.h"

#include "msrpstrings.h"

#include "MSRPStrConsts.h"

#include "RMSRPSession.h"

#include "MMSRPSessionObserver.h"

#include "CMSRPConnectionListener.h"

#include "CMSRPIncomingListener.h"

#include "CMSRPSendResultListener.h"

#include "CMSRPMessage.h"

#include "CMSRPToPathHeader.h"

#include "CMSRPFromPathHeader.h"

#include "CMSRPMessageIdHeader.h"

#include "CMSRPSuccessReportHeader.h"

#include "CMsrpFailureReportHeader.h"

#include "CMsrpContentTypeHeader.h"

#include "CMSRPSessionParams.h"

// SYSTEM INCLUDES

#include <e32math.h>

// Constants

const TInt KMsrpFixedLength=19; // fixed length of a uri

//  Member Functions

	{

	MSRPLOG("CMSRPSessionImplementation::NewL");

	CleanupStack::Pop(self);

	return self;

	}

    {

    MSRPLOG("CMSRPSessionImplementation::NewLC");

    CMSRPSessionImplementation *self = new (ELeave) CMSRPSessionImplementation( aRMSRP, aObserver );                                                            

    CleanupStack::PushL(self);                                                       

    return self;

    }

CMSRPSessionImplementation::CMSRPSessionImplementation( RMSRP& aRMSRP,

                                                        MMSRPSessionObserver& aObserver )

                                                        :iRMSRP(aRMSRP), 

                                                        iSessionObserver(aObserver),

                                                        iSuccessReport(ENo),

                                                        iFailureReport(EYes)

    {

    MSRPLOG("CMSRPSessionImplementation::Ctor");

	}

	{

	MSRPLOG("CMSRPSessionImplementation::ConstructL enter");

	MSRPStrings::OpenL();

	iMSRPSession = new ( ELeave ) RMSRPSession();

	MSRPLOG("Sub session opened successfully!");

	RBuf8 localHost;

	localHost.CreateL( KMaxLengthOfHost );

	CleanupClosePushL( localHost );

	iLocalMsrpPath.Append( localHost );

	iLocalMsrpPath.Append( KColon );

	iLocalMsrpPath.AppendNum( KMsrpPort );

	iLocalMsrpPath.Append( KForwardSlash );   

	iLocalMsrpPath.Append( KSemicolon );

	iLocalMsrpPath.Append( KTransport );

	iConnectionListener = CMSRPConnectionListener::NewL(

	        *this, *iMSRPSession );

	iIncomingListener = CMSRPIncomingListener::NewL(

	MSRPLOG("CMSRPSessionImplementation::ConstructL exit");

	}

CMSRPSessionImplementation::~CMSRPSessionImplementation()

    {

    MSRPLOG("CMSRPSessionImplementation::Dtor Entered");

    MSRPStrings::Close();

    iLocalMsrpPath.Close();

    iRemoteMsrpPath.Close();

    delete iConnectionListener;

    delete iIncomingListener;

    delete iSendResultListener;

    iSentMessages.ResetAndDestroy();

    iSentMessages.Close();

    if( iMSRPSession )

        {

        iMSRPSession->CloseServerSubSession();

        }    

    delete iMSRPSession;

    MSRPLOG("CMSRPSessionImplementation::Dtor Exit");    

    }

TDesC8& CMSRPSessionImplementation::LocalMSRPPath()

    {

    MSRPLOG("CMSRPSessionImplementation::LocalMSRPPath");

    return iLocalMsrpPath;

    }

void CMSRPSessionImplementation::SetSessionParams( CMSRPSessionParams& aSessionParams )

    {

    MSRPLOG("CMSRPSessionImplementation::SetSessionParams");

    iSuccessReport = aSessionParams.SuccessReportHeader();

    iFailureReport = aSessionParams.FailureReportHeader();

    }

void CMSRPSessionImplementation::GetRemotePathComponentsL( TPtrC8& aRemoteHost, TUint& aRemotePort, TPtrC8& aRemoteSessionID )

    {

    MSRPLOG("CMSRPSessionImplementation::GetRemotePathComponentsL enter");

    TUriParser8 parser;

    User::LeaveIfError( parser.Parse( iRemoteMsrpPath ) ); 

    aRemoteHost.Set( parser.Extract( EUriHost ) );

    const TDesC8& remPort = parser.Extract( EUriPort );

    TLex8 portLex(remPort);

    User::LeaveIfError( portLex.Val( aRemotePort ) );

    const TDesC8& remotePath = parser.Extract( EUriPath );

    TInt loc = remotePath.Find( KSemicolon );

    aRemoteSessionID.Set( remotePath.Mid( 1, loc-1) );    

    MSRPLOG("CMSRPSessionImplementation::GetRemotePathComponentsL exit");

    }

void CMSRPSessionImplementation::ConnectL( const TDesC8& aRemoteMsrpPath )

    {

    MSRPLOG("CMSRPSessionImplementation::ConnectL enter");

    iRemoteMsrpPath.CreateL( aRemoteMsrpPath );

    TPtrC8 remoteHost;

    TPtrC8 remoteSessionID;

    TUint remotePort;

    GetRemotePathComponentsL( remoteHost, remotePort, remoteSessionID );

    iConnectionListener->ConnectL( remoteHost, remotePort, remoteSessionID );

    MSRPLOG("CMSRPSessionImplementation::ConnectL exit");

    }

void CMSRPSessionImplementation::ListenL( const TDesC8& aRemoteMsrpPath )

    {    

    MSRPLOG("CMSRPSessionImplementation::ListenL enter");

    iRemoteMsrpPath.CreateL( aRemoteMsrpPath );

    TPtrC8 remoteHost;

    TPtrC8 remoteSessionID;

    TUint remotePort;

    GetRemotePathComponentsL( remoteHost, remotePort, remoteSessionID );

    iIncomingListener->ListenConnections( remoteHost, remotePort, remoteSessionID );     

    MSRPLOG("CMSRPSessionImplementation::ListenL exit");

    }

void CMSRPSessionImplementation::ConnectionEstablishedL( TInt aStatus )

    MSRPLOG("CMSRPSessionImplementation::ConnectionEstablished enter");

    iSessionObserver.ConnectStatus(aStatus);

    if ( aStatus == KErrNone )

        {

        // start listening to incoming messages directed to this session

        iIncomingListener->ListenMessages( );

        // start listening when message has been sent,  to responses

        }

    MSRPLOG("CMSRPSessionImplementation::ConnectionEstablished exit");

    }

void CMSRPSessionImplementation::HandleIncomingMessageL(

    const TDesC8& aIncomingMessage, TInt aStatus )

    {

    MSRPLOG( "CMSRPSessionImplementation::HandleIncomingMessageL enter" )

    // the incoming buffer must be internalized

    RDesReadStream readStream( aIncomingMessage );

    if ( CMSRPMessage::IsMessage( aIncomingMessage ) )

        {

        CMSRPMessage* message = NULL;

        message = CMSRPMessage::InternalizeL( readStream );

        CleanupStack::PushL(message);

            {

            }

        else

            {

            }

        }

    else

        {

        User::Leave( KErrArgument );

        }

    MSRPLOG( "CMSRPSessionImplementation::HandleIncomingMessageL exit" )

    }

    {

    }

    {

    }

CMSRPMessage* CMSRPSessionImplementation::CreateMsrpMessageL(

    const TDesC8& aMessage, const TDesC8& aToPath,

    const TDesC8& aFromPath, const TDesC8& aMimeType )

    {

    MSRPLOG( "CMSRPSessionImplementation::CreateMsrpMessageL enter" )

    // To path

    CMSRPMessage* msrpMessage = new ( ELeave ) CMSRPMessage();

    CleanupStack::PushL( msrpMessage );

    CMSRPToPathHeader* toPath = CMSRPToPathHeader::DecodeL( aToPath );

    msrpMessage->SetToPathHeader( toPath );

    // from path

    CMSRPFromPathHeader* fromPath = CMSRPFromPathHeader::DecodeL( aFromPath );

    msrpMessage->SetFromPathHeader( fromPath );

    // message id header

    TTime now;

    now.HomeTime();

    TInt64 seed = now.Int64();

    // Create a random number as the session ID

    TInt random = Math::Rand( seed );

    TBuf8< 100 > idString;

    idString.AppendNum( random );

    CMSRPMessageIdHeader* messageIdHeader = CMSRPMessageIdHeader::NewL( idString );

    msrpMessage->SetMessageIdHeader( messageIdHeader );

    // success report header

    if( iSuccessReport != ENo )

        {

        RStringF string = MSRPStrings::StringF( MSRPStrConsts::EYes );

        CMSRPSuccessReportHeader* successReportHeader = CMSRPSuccessReportHeader::NewL( string );

        msrpMessage->SetSuccessReportHeader( successReportHeader );

        }

    // failure report header

    if( iFailureReport != EYes )

        {

        RStringF string;

        CleanupClosePushL(string);

        if( iFailureReport == ENo )

            {

            string = MSRPStrings::StringF( MSRPStrConsts::ENo );

            }

        else

            {

            string = MSRPStrings::StringF( MSRPStrConsts::EPartial );

            }

        CMSRPFailureReportHeader* failureReportHeader = CMSRPFailureReportHeader::NewL( string );

        msrpMessage->SetFailureReportHeader( failureReportHeader );

        CleanupStack::PopAndDestroy(); // string

        }

    // content type

    if(aMimeType.Length())

        {

        CMSRPContentTypeHeader* contentType = CMSRPContentTypeHeader::NewL( aMimeType );

        msrpMessage->SetContentTypeHeader( contentType );

            {

            // content of the message

            HBufC8* contentOfMessage = HBufC8::NewL( aMessage.Length() );

            *contentOfMessage = aMessage;

            msrpMessage->SetContent( contentOfMessage );

        }

    CleanupStack::Pop(msrpMessage);

    MSRPLOG( "CMSRPSessionImplementation::CreateMsrpMessageL exit" )

    return msrpMessage;

    }

void CMSRPSessionImplementation::SendMessageL( CMSRPMessage* aMessage )

    {

    MSRPLOG( "CMSRPSessionImplementation::SendMessageL enter" )

    iSentMessages.AppendL( aMessage );

    // making sure the required headers are included

    if ( !aMessage->FromPathHeader() || !aMessage->ToPathHeader() || !aMessage->MessageIdHeader() )

        {

        User::Leave( KErrArgument );

        }

    CleanupStack::PushL( buf1 );

    RBufWriteStream writeStream( *buf1 );

    CleanupClosePushL( writeStream );

    aMessage->ExternalizeL( writeStream );

    writeStream.CommitL();

    // MSRP message externalized to buffer, now let's move it to flat buffer

    if ( buf1->Size() > KMaxLengthOfIncomingMessageExt )

        {

        // invalid message size

        User::Leave( KErrArgument );

        }

    buf1->Read( 0, iExtMessageBuffer, buf1->Size() );

    CleanupStack::PopAndDestroy( 2 ); // buf1, writestream

    // message creation complete, send the message

    // synchronously sent the message

    User::LeaveIfError( iMSRPSession->SendMessage( iExtMessageBuffer ) );

    MSRPLOG( "CMSRPSessionImplementation::SendMessageL exit" )

    }

HBufC8* CMSRPSessionImplementation::SendBufferL(

    const TDesC8& aMessage,

    const TDesC8& aMimeType )

    {

    MSRPLOG( "CMSRPSessionImplementation::SendBufferL enter" )

    CMSRPMessage* msrpMessage = CreateMsrpMessageL(

                                aMessage, iRemoteMsrpPath, iLocalMsrpPath, aMimeType );

    CleanupStack::PushL( msrpMessage );

    SendMessageL( msrpMessage );

    HBufC8* messageId = msrpMessage->MessageIdHeader()->ToTextValueLC();

    CleanupStack::Pop(messageId);

    CleanupStack::Pop( msrpMessage );

    MSRPLOG( "CMSRPSessionImplementation::SendBufferL exit" )

    return messageId;

    }

void CMSRPSessionImplementation::CancelSendingL( TDesC8& aMessageId )

    {

    MSRPLOG( "CMSRPSessionImplementation::CancelSendingL " )

    // then let's send a message to server to cancel sending

    User::LeaveIfError( iMSRPSession->CancelSending( aMessageId ) );

    }

void CMSRPSessionImplementation::SendStatusL( TInt aStatus, const TDesC8& aMessageid )

    {

    MSRPLOG2( "CMSRPSessionImplementation::SendStatus = %d", aStatus )

        {

            {

            CleanupStack::PopAndDestroy(messageid); // messageid from above

            }

        }

    MSRPLOG( "CMSRPSessionImplementation::SendStatus exit" )

    }

void CMSRPSessionImplementation::HandleConnectionErrors( TInt aErrorStatus )

    {

    MSRPLOG2( "CMSRPSessionImplementation::HandleConnectionErrors Error = %d", aErrorStatus )

    }

    {

    if(aFileName.Length() && !aMimeType.Length())

        {