/*
* 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:    
*
*/






#ifndef MCESRVLOGS_H
#define MCESRVLOGS_H

#include <in_sock.h>
#include "mcecomlogs.h"
#include "mceevents.h"
#include "mceclientserver.h"
#include "mcesession.h"
#include "mceaudiostream.h"
#include "sipstrconsts.h"

// INCLUDES

// FORWARD DECLARATIONS

// CLASS DECLARATION

#ifdef MCESRV_UNIT_TEST_COVERAGE

#undef _DEBUG

#endif

/**
 * Class provides logging through RDebug in debug builds
 * 'MCE: ' added automatically in fron of every logged line
 */ 
class TMceSrvDebug 
	{
	public:

#ifdef _DEBUG

	inline static void Print( const TDesC16& aStr ) 
		{
		TChar notAllowed('%');
		if ( aStr.Locate( notAllowed ) == KErrNotFound )
			{
			_LIT(KMceFormat, "[Server] %S");

			TBuf<256> str;
			str.Format(KMceFormat, &aStr);
			TMceDebug::Print( str, ETrue );
			}
		else
			{
			_LIT(KMceWarning, "MCE: Text contains not allowed characters, log ignored");
			RDebug::Print( KMceWarning );							
			}	
		}

	inline static void Print( const TDesC16& aStr1, TUint32 aValue1 )
		{
		TChar notAllowed('%');
		if ( aStr1.Locate( notAllowed ) == KErrNotFound )
			{
			_LIT(KMceFormat, "[Server] %S=%d");
			TBuf<256> str;
			str.Format(KMceFormat, &aStr1, aValue1);
			TMceDebug::Print( str, ETrue );
			}
		else
			{
			_LIT(KMceWarning, "MCE: Text contains not allowed characters, log ignored");
			RDebug::Print( KMceWarning );							
			}	
		}

	inline static void Print( const TDesC16& aStr1, const TDesC16& aStr2 )
		{
		TChar notAllowed('%');
		if ( aStr1.Locate( notAllowed ) == KErrNotFound  &&
		     aStr2.Locate( notAllowed ) == KErrNotFound )
			{
			_LIT(KMceFormat, "[Server] %S=%S");
			TBuf<256> str;
			str.Format(KMceFormat, &aStr1, &aStr2);
			TMceDebug::Print( str, ETrue );
			}
		else
			{
			_LIT(KMceWarning, "MCE: Text contains not allowed characters, log ignored");
			RDebug::Print( KMceWarning );							
			}	
		}

	inline static void Print( const TDesC16& aStr1, TUint32 aValue1, const TDesC16& aStr2, TUint32 aValue2 ) 
		{
		TChar notAllowed('%');
		if ( aStr1.Locate( notAllowed ) == KErrNotFound )
			{
			_LIT(KMceFormat, "[Server] %S=%d, %S=%d");
			TBuf<256> str;
			str.Format(KMceFormat, &aStr1, aValue1, &aStr2, aValue2 );
			TMceDebug::Print( str );
			}
		else
			{
			_LIT(KMceWarning, "MCE: Text contains not allowed characters, log ignored");
			RDebug::Print( KMceWarning );							
			}	
		}

	inline static void Print( const TDesC16& aStr1, TUint32 aValue1, const TDesC16& aStr2 ) 
		{
		TChar notAllowed('%');
		if ( aStr1.Locate( notAllowed ) == KErrNotFound )
			{
			_LIT(KMceFormat, "[Server] %S=%d %S");
			TBuf<256> str;
			str.Format(KMceFormat, &aStr1, aValue1, &aStr2 );
			TMceDebug::Print( str );
			}
		else
			{
			_LIT(KMceWarning, "MCE: Text contains not allowed characters, log ignored");
			RDebug::Print( KMceWarning );							
			}	
		}

	inline static void Print( const TDesC16& aStr1, const TDesC8& aValue1 ) 
	    {
		TChar notAllowed('%');
		if ( aStr1.Locate( notAllowed ) == KErrNotFound )
			{
			TBuf<100> str2;
			CnvUtfConverter::ConvertToUnicodeFromUtf8(str2, aValue1);

			_LIT(KMceFormat, "[Server] %S=\"%S\"");
			TBuf<256> str;
			str.Format(KMceFormat, &aStr1, &str2);
			TMceDebug::Print( str );
			}
		else
			{
			_LIT(KMceWarning, "MCE: Text contains not allowed characters, log ignored");
			RDebug::Print( KMceWarning );							
			}		    
	    }
	    
    inline static void Print( const TDesC16& aStr, const TInetAddr& aAddr )
        {
        const TInt KIPv6AddrMaxLen = 39;
		TChar notAllowed('%');
		if ( aStr.Locate( notAllowed ) == KErrNotFound )
			{
            TBuf<KIPv6AddrMaxLen> addrBuf;
            aAddr.Output(addrBuf);
    		_LIT(KMceFormat, "MCE: [Server] %S=%S port %d");
    		TBuf<256> str;
            str.Format(KMceFormat, &aStr, &addrBuf, aAddr.Port());
            RDebug::RawPrint(str);
			}
		else
			{
			_LIT(KMceWarning, "MCE: Text contains not allowed characters, log ignored");
			RDebug::Print( KMceWarning );							
			}		    
        }
	    

#endif

	};


#ifdef _DEBUG 

#define MCESRV_DEBUG( a ) { TMceSrvDebug::Print( _L( a ) ); }
#define MCESRV_DEBUG2( a, b ) { TMceSrvDebug::Print( _L( a ), _L( b ) ); }
#define MCESRV_DEBUG_DVALUE( a, b ) { TMceSrvDebug::Print( _L( a ),  b  ); }
#define MCESRV_DEBUG_ADDRVALUE( a, b ) { TMceSrvDebug::Print( _L( a ),  b  ); }
#define MCESRV_DEBUG_DVALUES( a, b, c, d ) { TMceSrvDebug::Print( _L( a ),  b, _L( c ), d  ); }
#define MCESRV_DEBUG_SVALUE( a, b ) { TMceSrvDebug::Print( _L( a ), b ); }
#define MCESRV_DEBUG_SVALUE16( a, b ) { TMceSrvDebug::Print( _L( a ), b ); }

#define MCESRV_DEBUG_CALLBACK( str, callback )\
        MCE_DEBUG_CALLBACK( TMceSrvDebug, str, callback )

#define MCESRV_DEBUG_DATATYPE( str, datatype )\
        MCE_DEBUG_DATATYPE( TMceSrvDebug, str, datatype )
        
#define MCESRV_DEBUG_CLISTATE( str, state )\
        MCE_DEBUG_CLISTATE( TMceSrvDebug, str, state )
        
#define MCESRV_DEBUG_ITC( str, event )\
        MCE_DEBUG_ITC( TMceSrvDebug, str, event )

#define MCESRV_DEBUG_SESSIONTYPE( str, type )\
        MCE_DEBUG_SESSIONTYPE( TMceSrvDebug, str, type )

#define MCESRV_DEBUG_DIALOGTYPE( str, type )\
        MCE_DEBUG_DIALOGTYPE( TMceSrvDebug, str, type )

#define MCESRV_DEBUG_MEDIASTATE( str, state )\
        MCE_DEBUG_MEDIASTATE( TMceSrvDebug, str, state )

#define MCESRV_DEBUG_EVENTSTATE( str, state )\
        MCE_DEBUG_EVENTSTATE( TMceSrvDebug, str, state )

#define MCESRV_DEBUG_ARRAY( str, line, array )\
    if ( array )\
        {\
        MCESRV_DEBUG( str );\
        for( TInt _mced_array_ndx=0;_mced_array_ndx < array->MdcaCount();_mced_array_ndx++ )\
            {\
            MCESRV_DEBUG_SVALUE( line, array->MdcaPoint( _mced_array_ndx ) );\
            }\
        }


//        MCE_DEBUG_ARRAY( TMceSrvDebug, str, line, array )

#define MCESRV_DEBUG_METHOD( str, method )\
    switch( method )\
        {\
        case SipStrConsts::EInvite:{ MCESRV_DEBUG2( str, "INVITE" );break; }\
        case SipStrConsts::EUpdate:{ MCESRV_DEBUG2( str, "UPDATE" );break; }\
        case SipStrConsts::EPrack:{ MCESRV_DEBUG2( str, "PRACK" );break; }\
        case SipStrConsts::EBye:{ MCESRV_DEBUG2( str, "BYE" );break; }\
        case SipStrConsts::ESubscribe:{ MCESRV_DEBUG2( str, "SUBSCRIBE" );break; }\
        case SipStrConsts::ERefer:{ MCESRV_DEBUG2( str, "REFER" );break; }\
        case SipStrConsts::EOptions:{ MCESRV_DEBUG2( str, "OPTIONS" );break; }\
        case SipStrConsts::EAck:{ MCESRV_DEBUG2( str, "ACK" );break; }\
        default:{ MCESRV_DEBUG2( str, "UNKNOWN METHOD" );break; }\
        }
    
    
#define MCESRV_DEBUG_STATE( str, state )\
    switch( state )\
        {\
        case KMceStateIdle:{ MCESRV_DEBUG2( str, "KMceStateIdle" );break; }\
        case KMceStateClientEstablishing:{ MCESRV_DEBUG2( str, "KMceStateClientEstablishing" );break; }\
        case KMceStateOffering:{ MCESRV_DEBUG2( str, "KMceStateOffering" );break; }\
        case KMceStateEstablished:{ MCESRV_DEBUG2( str, "KMceStateEstablished" );break; }\
        case KMceStateTerminating:{ MCESRV_DEBUG2( str, "KMceStateTerminating" );break; }\
        case KMceStateTerminated:{ MCESRV_DEBUG2( str, "KMceStateTerminated" );break; }\
        case KMceStateServerEstablishing:{ MCESRV_DEBUG2( str, "KMceStateServerEstablishing" );break; }\
        case KMceStateUpdating:{ MCESRV_DEBUG2( str, "KMceStateUpdating" );break; }\
        case KMceStateUpdated:{ MCESRV_DEBUG2( str, "KMceStateUpdated" );break; }\
        case KMceStateAnswering:{ MCESRV_DEBUG2( str, "KMceStateAnswering" );break; }\
        case KMceStateError:{ MCESRV_DEBUG2( str, "KMceStateError" );break; }\
        case KMceStateCanceled:{ MCESRV_DEBUG2( str, "KMceStateCanceled" );break; }\
        default:{ MCESRV_DEBUG_DVALUE( str, state );break; }\
        }

#define MCESRV_DEBUG_MCE_EVENT( str, event )\
    switch( (TMceMediaEventCode)event )\
        {\
        case EMceMediaSessionStopped:{ MCESRV_DEBUG2( str, "EMceMediaSessionStopped" );break; }\
        case EMceMediaError:{ MCESRV_DEBUG2( str, "EMceMediaError" );break; }\
        case EMceMediaReserved:{ MCESRV_DEBUG2( str, "EMceMediaReserved" );break; }\
        case EMceMediaUpdated:{ MCESRV_DEBUG2( str, "EMceMediaUpdated" );break; }\
        case EMceMediaEventReceived:{ MCESRV_DEBUG2( str, "EMceMediaEventReceived" );break; }\
        default:{ MCESRV_DEBUG_SIP_EVENT( str, event );break; }\
        }
        

#define MCESRV_DEBUG_SIP_EVENT( str, event )\
    switch( (TMceSipEventCode)event )\
        {\
        case EMceRegister:{ MCESRV_DEBUG2( str, "EMceRegister" );break; }\
        case EMceInvite:{ MCESRV_DEBUG2( str, "EMceInvite" );break; }\
        case EMceCancel:{ MCESRV_DEBUG2( str, "EMceCancel" );break; }\
        case EMceAck:{ MCESRV_DEBUG2( str, "EMceAck" );break; }\
        case EMceBye:{ MCESRV_DEBUG2( str, "EMceBye" );break; }\
        case EMcePrack:{ MCESRV_DEBUG2( str, "EMcePrack" );break; }\
        case EMceUpdate:{ MCESRV_DEBUG2( str, "EMceUpdate" );break; }\
        case EMceSubscribe:{ MCESRV_DEBUG2( str, "EMceSubscribe" );break; }\
        case EMceRefer:{ MCESRV_DEBUG2( str, "EMceRefer" );break; }\
        case EMceMessage:{ MCESRV_DEBUG2( str, "EMceMessage" );break; }\
        case EMceInfo:{ MCESRV_DEBUG2( str, "EMceInfo" );break; }\
        case EMceResponse:{ MCESRV_DEBUG2( str, "EMceResponse" );break; }\
        case EMceProvisionalResponse:{ MCESRV_DEBUG2( str, "EMceProvisionalResponse" );break; }\
        case EMceRedirectionResponse:{ MCESRV_DEBUG2( str, "EMceRedirectionResponse" );break; }\
        case EMceErrorResponse:{ MCESRV_DEBUG2( str, "EMceErrorResponse" );break; }\
        case EMceStandAloneRequest:{ MCESRV_DEBUG2( str, "EMceStandAloneRequest" );break; }\
        case EMceStandAloneResponse:{ MCESRV_DEBUG2( str, "EMceStandAloneResponse" );break; }\
        case EMceSessionExpired:{ MCESRV_DEBUG2( str, "EMceSessionExpired" );break; }\
        case EMceSessionRefresh:{ MCESRV_DEBUG2( str, "EMceSessionRefresh" );break; }\
        default:{ MCESRV_DEBUG_DVALUE( str, event );break; }\
        }

#define MCESRV_DEBUG_EVENT( str, event )\
    if( (TMceItcFunctions)event <= EMceItcCancelTranscode )\
        {\
        MCESRV_DEBUG_ITC( str, event );\
        }\
    else if ( (TMceMediaEventCode)event >= EMceMediaSessionStopped && (TMceMediaEventCode)event <= EMceMediaEventReceived )\
        {\
        MCESRV_DEBUG_MCE_EVENT( str, event );\
        }\
    else if ( (TMceSipEventCode)event >= EMceRegister && (TMceSipEventCode)event <= EMceReliableFailed )\
        {\
        MCESRV_DEBUG_SIP_EVENT( str, event );\
        }
    

#define MCESRV_DEBUG_SUBSTATE( str, state )\
    switch( state )\
        {\
        case CMceSipSession::ENone:{ MCESRV_DEBUG2( str, "ENone" );break; }\
        case CMceSipSession::EOffering:{ MCESRV_DEBUG2( str, "EOffering" );break; }\
        case CMceSipSession::EAnswering:{ MCESRV_DEBUG2( str, "EAnswering" );break; }\
        case CMceSipSession::EUpdating:{ MCESRV_DEBUG2( str, "EUpdating" );break; }\
        case CMceSipSession::ERefreshing:{ MCESRV_DEBUG2( str, "ERefreshing" );break; }\
        default:{ MCESRV_DEBUG_DVALUE( str, state );break; }\
        }
        
#define MCESRV_DEBUG_IDS( str, ids )\
    MCESRV_DEBUG( str );\
    MCESRV_DEBUG_DVALUE("application uid", ids.iAppUID );\
    MCESRV_DEBUG_SESSIONTYPE("session type", ids.iManagerType );\
    MCESRV_DEBUG_DVALUE("session id", ids.iSessionID );\
    MCESRV_DEBUG_DIALOGTYPE("dialog type", ids.iDialogType );\
    MCESRV_DEBUG_DVALUE("dialog id", ids.iDialogID );\
    MCESRV_DEBUG_DVALUE("profile id", ids.iProfileID );\
    MCESRV_DEBUG_DATATYPE("message type", ids.iMsgType );\
    MCESRV_DEBUG_CALLBACK( "callback", ids.iCallbackID );\
    MCESRV_DEBUG_CLISTATE("state", ids.iState );\
    MCESRV_DEBUG_DVALUE("spare1", ids.iSpare1 );\
    MCESRV_DEBUG_DVALUE("spare2", ids.iSpare2 );\
    MCESRV_DEBUG_DVALUE("status", ids.iStatus );\
    MCESRV_DEBUG_DVALUE("media id", ids.iMediaID.iId );\
    MCESRV_DEBUG_DVALUE("source id", ids.iSourceID.iId );\
    MCESRV_DEBUG_DVALUE("sink id", ids.iSinkID.iId );\
    MCESRV_DEBUG_DVALUE("codec id", ids.iCodecID.iId )


#define MCESRV_DEBUG_CODEC( str, codec )\
    if ( codec )\
        {\
        MCESRV_DEBUG( str );\
        MCESRV_DEBUG_DVALUES("  iID.iAppId", codec->iID.iAppId, "iID.iId", codec->iID.iId );\
        MCESRV_DEBUG_DVALUE( "  iEnableVAD", codec->iEnableVAD );\
        MCESRV_DEBUG_DVALUE( "  iSamplingFreq", codec->iSamplingFreq );\
        MCESRV_DEBUG_SVALUE( "  iSdpName", codec->iSdpName );\
        MCESRV_DEBUG_DVALUE( "  iPTime", codec->iPTime );\
        MCESRV_DEBUG_DVALUE( "  iMaxPTime", codec->iMaxPTime );\
        MCESRV_DEBUG_DVALUE( "  iBitrate", codec->iBitrate );\
        MCESRV_DEBUG_DVALUE( "  iAllowedBitrates", codec->iAllowedBitrates );\
        MCESRV_DEBUG_DVALUE( "  iPayloadType", codec->iPayloadType );\
        MCESRV_DEBUG_DVALUE( "  iCodecMode", codec->iCodecMode );\
        MCESRV_DEBUG_DVALUE( "  iFourCC", codec->iFourCC );\
        MCESRV_DEBUG_SVALUE( "  iFmtpAttr", codec->iFmtpAttr ? *codec->iFmtpAttr : KNullDesC8() );\
        MCESRV_DEBUG_DVALUE( "  iFrameSize", codec->iFrameSize );\
        MCESRV_DEBUG_DVALUE( "  iStream", (TUint32)codec->Stream() );\
        }

#define _MCESRV_DEBUG_MEDIASTREAM( str, media )\
        MCESRV_DEBUG( str );\
        MCESRV_DEBUG_DVALUES(" iID.iAppId", media->iID.iAppId, "iID.iId", media->iID.iId );\
        MCESRV_DEBUG_DVALUE( " iType", media->iType );\
        MCESRV_DEBUG_DVALUE( " iIsEnabled", media->iIsEnabled );\
        MCESRV_DEBUG_DVALUE( " iLocalMediaPort", media->iLocalMediaPort );\
        MCESRV_DEBUG_DVALUE( " iRemoteMediaPort", media->iRemoteMediaPort );\
        MCESRV_DEBUG_DVALUE( " iRemoteRtcpPort", media->iRemoteRtcpPort );\
        MCESRV_DEBUG_ARRAY(  " iLocalMediaSDPLines:", "  medialine", media->iLocalMediaSDPLines );\
        MCESRV_DEBUG_ARRAY(  " iRemoteMediaSDPLines:", "  medialine", media->iRemoteMediaSDPLines );\
        MCESRV_DEBUG_DVALUE( " iSession", (TUint32)media->Session() )

        
#define MCESRV_DEBUG_MEDIASTREAM( str, media )\
    if ( media )\
        {\
        _MCESRV_DEBUG_MEDIASTREAM( str, media );\
        if ( media->iType == KMceAudio )\
            {\
            CMceComAudioStream* audio = static_cast<CMceComAudioStream*>( media );\
            TInt _mced_codec_ndx = 0;\
            for( _mced_codec_ndx=0;_mced_codec_ndx < audio->CodecCount();_mced_codec_ndx++)\
                {\
                MCESRV_DEBUG_CODEC( "  codec:", audio->CodecL( _mced_codec_ndx ) );\
                }\
            if ( audio->iLinkedStream )\
                {\
                _MCESRV_DEBUG_MEDIASTREAM( " linked stream:", audio->iLinkedStream );\
                if ( audio->iLinkedStream->iType == KMceAudio )\
                    {\
                    audio = static_cast<CMceComAudioStream*>( audio->iLinkedStream );\
                    for( _mced_codec_ndx=0;_mced_codec_ndx < audio->CodecCount();_mced_codec_ndx++)\
                        {\
                        MCESRV_DEBUG_CODEC( "  codec:", audio->CodecL( _mced_codec_ndx ) );\
                        }\
                    }\
                }\
            }\
        }

/*lint -e666 */

#define MCESRV_DEBUG_COMSESSION( body )\
    MCESRV_DEBUG_DVALUE("id", body->iID );\
    MCESRV_DEBUG_DVALUE("type", body->iType );\
    MCESRV_DEBUG_DVALUE("state", body->iState );\
    MCESRV_DEBUG_SVALUE("recipient", body->iRecipient ? *body->iRecipient : KNullDesC8() );\
    MCESRV_DEBUG_SVALUE("originator", body->iOriginator ? *body->iOriginator : KNullDesC8() );\
    MCESRV_DEBUG_DVALUE("connectionActive", body->iIsConnectionActive );\
    MCESRV_DEBUG_DVALUE("dialog id", body->iDialogId );\
    MCESRV_DEBUG_DVALUE("iap id", body->iIapId );\
    MCESRV_DEBUG_DVALUE("timeout", body->iTimeout );\
    MCESRV_DEBUG_DVALUE("min se", body->iMinSE );\
    MCESRV_DEBUG_DVALUE("refresher", body->iRefresh );\
    MCESRV_DEBUG_DVALUE("mcc id", body->iMccID );\
    MCESRV_DEBUG_ARRAY( "SIP headers:", " header", body->iSIPHeaders );\
    MCESRV_DEBUG_ARRAY( "local session SDP lines:", "  medialine", body->iLocalSessionSDPLines );\
    MCESRV_DEBUG_ARRAY( "remote session SDP lines:", "  medialine", body->iRemoteSessionSDPLines );\
    MCESRV_DEBUG_SVALUE("content type", body->iSIPContentType ? *body->iSIPContentType : KNullDesC8() );\
    for( TInt _mced_stream_ndx=0; _mced_stream_ndx < body->Streams().Count(); _mced_stream_ndx++ )\
        {\
        MCESRV_DEBUG_MEDIASTREAM( " stream:",  body->Streams()[ _mced_stream_ndx ] );\
        }

#else


#define MCESRV_DEBUG( a )
#define MCESRV_DEBUG2( a, b )
#define MCESRV_DEBUG_DVALUE( a, b )
#define MCESRV_DEBUG_ADDRVALUE( a, b )
#define MCESRV_DEBUG_DVALUES( a, b, c, d )
#define MCESRV_DEBUG_SVALUE( a, b )
#define MCESRV_DEBUG_SVALUE16( a, b )
#define MCESRV_DEBUG_CALLBACK( str, callback )
#define MCESRV_DEBUG_DATATYPE( str, datatype )
#define MCESRV_DEBUG_CLISTATE( str, state )
#define MCESRV_DEBUG_ITC( str, event )
#define MCESRV_DEBUG_SESSIONTYPE( str, type )
#define MCESRV_DEBUG_DIALOGTYPE( str, type )
#define MCESRV_DEBUG_MEDIASTATE( str, state )
#define MCESRV_DEBUG_EVENTSTATE( str, state )
#define MCESRV_DEBUG_ARRAY( str, line, array )
#define MCESRV_DEBUG_METHOD( str, method )
#define MCESRV_DEBUG_STATE( str, state )
#define MCESRV_DEBUG_CLISTATE( str, state )
#define MCESRV_DEBUG_EVENT( str, event )
#define MCESRV_DEBUG_MCE_EVENT( str, event )
#define MCESRV_DEBUG_SIP_EVENT( str, event )
#define MCESRV_DEBUG_SUBSTATE( str, state )
#define MCESRV_DEBUG_IDS( str, ids )
#define MCESRV_DEBUG_CALLBACK( str, callback )
#define MCESRV_DEBUG_CODEC( str, codec )
#define MCESRV_DEBUG_MEDIASTREAM( str, audio )
#define _MCESRV_DEBUG_MEDIASTREAM( str, media )
#define MCESRV_DEBUG_COMSESSION( body )

#endif

#endif

// End of File