#include "misiobjectrouterif.h"   // For MISIObjectRouterIf

#include "namerecords.h"          // For DNameRecords

#include "routerisi.h"            // For PN_ROUTER

#include <commisi.h>              // For SIZE_COMMON_MESSAGE_COMM_ISA_ENTITY_NOT_REACHABLE_RESP

#ifdef ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE

#include "ape_commgrisi.h"          // For APE_COMMGR

#define ISCE_INTERNAL_EXTENDED_RESOURCE_ROUTING_SUPPORTED

//#include "isinameserviceextended.h" // For DISINameServiceExtended

    EISINameServiceNullPointer1,

    EISINameServiceNullPointer2,

    EISINameServiceNullPointer6,

    EISINameServiceNullPointer7,

    EISINameServiceNullPointer8,

    EISINameServiceNullPointer9,

    EISINameServiceNullPointer10,

    EISINameServiceNullPointer11,

    EISINameServiceNullPointer12,

    EISINameServiceNullPointer13,

    EISINameServiceNullPointer14,

    EISINameServiceNullPointer15,

    EISINameServiceNullPointer16,

    EISINameServiceNullPointer17,

    EISINameServiceNullPointer18,

    EISINameServiceNullPointer19,

    EISINameServiceWrongLength,

    EISINameServiceWrongLength1,

    EISINameServiceWrongLength6,

    EISINameServiceWrongLength7,

    EISINameServiceWrongLength8,

    EISINameServiceWrongLength9,

    EISINameServiceWrongLength10,

    EISINameServiceWrongLength11,

    EISINameServiceWrongLength12,

    EISINameServiceSendFailed,

    EISINameServiceFatalError,

#ifdef ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE

    EISINameServiceWrongLength2,

    EISINameServiceWrongLength3,

    EISINameServiceNullPointer3,

    EISINameServiceNullPointer4,

    EISINameServiceNullPointer5,

    EISINameServiceNameCreateFailed,

    EISINameServiceNameCreateFailed1,

    EISINameServiceNameCreateFailed2,

    EISINameServiceNameCreateFailed3,

    EISINameServiceNameCreateFailed4,

    EISINameServiceNameCreateFailed5,

    EISINameServiceNameCreateFailed6,

    EISINameServiceNameCreateFailed7,

    EISINameServiceNameCreateFailed8,

    EISINameServiceNameCreateFailed9,

    EISINameServiceNameCreateFailed10,

    EISINameServiceNameCreateFailed11,

    EISINameServiceNameCreateFailed12,

    EISINameServiceNameCreateFailed13,

    EISINameServiceNameCreateFailed14,

    EISINameServiceNameCreateFailed15,

    EISINameServiceNameCreateFailed16,

    EISINameServiceNameCreateFailed17,

    EISINameServiceNameCreateFailed18,

    EISINameServiceWrongResponse,

    EISINameServiceNameExtendedCreateFailed,

    EISINameServiceExtendedNullPointer,

    EISINameServiceNameNotCommgrResource,

    EISINameServiceNameNotCommgrDevice,

    EISINameServiceLookUpForPhoNetAddressAndFlagsFailed,

#endif // ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE

const TUint8 KAlwaysAssert( 0x00 );

const TUint16 KOneMatch( 0x00001 );

const TUint8 KEightBitShift( 8 );

const TUint8 KSixteenBitShift( 16 );

const TUint8 KDeviceIdentifierPhoNetAddressShift( KEightBitShift );

const TUint16 KUninitializedPhoNetAddress( 0x0000 );

const TUint8 KRouterObjId( 0xFA ); // Only internally agreed inside isi router

    ASSERT_RESET_ALWAYS( ( iNameRecords ), 

                         ( EISINameServiceMemAllocFailure | EDISINameServiceTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( KErrNone == err ), 

                         ( EISINameServiceMutexCreateFailed | EDISINameServiceTraceId << KClassIdentifierShift ) );

    iRouter = MISIObjectRouterIf::GetIf();

    ASSERT_RESET_ALWAYS( ( iRouter ),

                         ( EISINameServiceNullPointer | EDISINameServiceTraceId << KClassIdentifierShift ) );

    iRouter->Connect( KNameServiceUID, iObjId, this );

    C_TRACE( ( _T( "DISINameService::DISINameService 0x%x" ), iObjId ) );

    ASSERT_RESET_ALWAYS( ( iObjId == PN_OBJ_ROUTING_REQ ), 

                         ( EISINameServiceFatalError | EDISINameServiceTraceId << KClassIdentifierShift ) );

    // Starting from here we add the PN_ROUTER object 'statically' to Name Service

    TUint32 name = PN_ROUTER;

    TUint16 phonetAddr = ( ( PN_DEV_OWN << KDeviceIdentifierPhoNetAddressShift ) | KRouterObjId );

    TUint8 flags = PN_NAME_NOCHG;

    err = iNameRecords->AddName( name, phonetAddr, flags );

#ifdef ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE

    iISINameServiceExtended = new DISINameServiceExtended( this );

    ASSERT_RESET_ALWAYS( ( iISINameServiceExtended ), ( EISINameServiceNameExtendedCreateFailed | EDISINameServiceTraceId << KClassIdentifierShift ) );

#endif // ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE

    iThisptr = this;

#ifdef ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE

    if( iISINameServiceExtended )

        {

        delete iISINameServiceExtended;

        iISINameServiceExtended = NULL;

        }

#endif

void DISINameService::Receive(

        const TDesC8& aMessage

        )

    // This to be signaled (and only) when send back.

    LockNameServiceDMutex();

    TUint32 resource = GetResourceUsedInMessage( aMessage );

    if( resource == PN_NAMESERVICE 

        )

        {

        C_TRACE( ( _T( "DISINameService::Receive to PN_NAMESERVICE" ) ) );

        HandlePnsNameMessage( aMessage );

        }

    // Messages which are to be Resource routed.

        C_TRACE( ( _T( "DISINameService::Receive to Resource : 0x%x" ),resource  ) );

        TUint16 phoNetAddress( KUninitializedPhoNetAddress );

        TInt32 error = iNameRecords->LookupPhonetAddress( resource, &phoNetAddress );

            // Change phonet addr to current message from table entries.

            msgPtr[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] = (TUint8) ( phoNetAddress >> KEightBitShift );

            msgPtr[ ISI_HEADER_OFFSET_RECEIVEROBJECT ] = (TUint8) ( phoNetAddress );

            TDes8* messagePtr = reinterpret_cast<TDes8*>( const_cast<TDesC8*>( &aMessage ) );

            C_TRACE( ( _T( "DISINameService message to recDev: 0x%x recObj: 0x%x" ), msgPtr[ ISI_HEADER_OFFSET_RECEIVERDEVICE ], msgPtr[ ISI_HEADER_OFFSET_RECEIVEROBJECT ] ) );

            SendToRouter( *messagePtr );

            C_TRACE( ( _T( "DISINameService::Receive no Resource found : 0x%x" ), resource  ) );

            TRACE_ASSERT_ALWAYS( KAlwaysAssert );

    C_TRACE( ( _T( "DISINameService::Receive 0x%x<" ), &aMessage ) );

void DISINameService::HandleNameQueryReq(

        const TDesC8& aPnsNameQueryReq

        )

    C_TRACE( ( _T( "DISINameService::HandleNameQueryReq 0x%x>" ) ,&aPnsNameQueryReq ) );

    const TUint8* msgPtr = aPnsNameQueryReq.Ptr();

    ASSERT_RESET_ALWAYS( msgPtr, ( EISINameServiceNullPointer6 | EDISINameServiceTraceId << KClassIdentifierShift ) );

    RArray <TNameTableEntry*> nameTable;

    iNameRecords->NameQuery( name, mask, &nameTable );

    TUint32 count( nameTable.Count() );

    // Hoks! not needed ISI_HEADER_SIZE because in below resp contains assumption that there is one entry always.

    ASSERT_RESET_ALWAYS( respPtr, ( EISINameServiceNullPointer7 | EDISINameServiceTraceId << KClassIdentifierShift ) );

    SetIsiHeaderForResp( respMsg, aPnsNameQueryReq, PNS_NAME_QUERY_RESP );

    PUTB16( &respPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_TOTALMATCHES ], count );

    PUTB16( &respPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_MATCHESINMSG ], count );

    TUint16 index( ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_NAMEENTRYTBL );

    C_TRACE( ( _T( "DISINameService::HandleNameQueryReq 0x%x entry count %d" ) ,&aPnsNameQueryReq, count ) );

    for( TInt i( 0 ); i < count; i++ )

        ASSERT_RESET_ALWAYS( ( respMsg.Length() > index + PN_NAME_SRV_ITEM_STR_OFFSET_RESERVED ),

                             ( EISINameServiceWrongLength7 | EDISINameServiceTraceId << KClassIdentifierShift ) );

        TNameTableEntry* tmp = ( nameTable )[ i ];

        if ( ( (TUint8)( tmp->iPhonetAddress ) == PN_OBJ_ROUTING_REQ ) && 

             ( tmp->iName == name ) )

            {

            TRACE_ASSERT_ALWAYS( KAlwaysAssert );

            Kern::Printf("PNS_NAME_QUERY_REQ NOTE! Obj Id 0 not valid!! name 0x%08x txDev 0x%02x txObj 0x%02x", name, msgPtr[ISI_HEADER_OFFSET_SENDERDEVICE], msgPtr[ISI_HEADER_OFFSET_SENDEROBJECT] );

            }

        PUTB32( &respPtr[ index + PN_NAME_SRV_ITEM_STR_OFFSET_NAME ],  tmp->iName );

        respPtr[ index + PN_NAME_SRV_ITEM_STR_OFFSET_DEV ] = (TUint8)( tmp->iPhonetAddress >> KEightBitShift );

        respPtr[ index + PN_NAME_SRV_ITEM_STR_OFFSET_OBJ ] = (TUint8)( tmp->iPhonetAddress );

        respPtr[ index + PN_NAME_SRV_ITEM_STR_OFFSET_FLAGS ] = tmp->iFlags;

        respPtr[ index + PN_NAME_SRV_ITEM_STR_OFFSET_RESERVED ] = KFiller;

        index += SIZE_PN_NAME_SRV_ITEM_STR;

    SendToRouter( respMsg );

    TDes8* block = reinterpret_cast<TDes8*>( const_cast<TDesC8*>(&aPnsNameQueryReq) );

    C_TRACE( ( _T( "DISINameService::HandleNameQueryReq 0x%x<" ) ,&aPnsNameQueryReq  ) );

void DISINameService::HandleNameRemoveReq(

        const TDesC8& aPnsNameRemoveReq

        )

    C_TRACE( ( _T( "DISINameService::HandleNameRemoveReq 0x%x>" ), &aPnsNameRemoveReq ) );

    const TUint8* msgPtr = aPnsNameRemoveReq.Ptr();

    ASSERT_RESET_ALWAYS( msgPtr, ( EISINameServiceNullPointer8 | EDISINameServiceTraceId << KClassIdentifierShift ) );

    TUint16 phonetAddress( KUninitializedPhoNetAddress );

    TUint8 flags( 0x00 );

    // Need to get these values in here to guarantee that they are the same in IND if needed.

    TInt error = iNameRecords->LookupNamePhonetAddressAndFlags( name, &phonetAddress, &flags );

    TRACE_ASSERT_ALWAYS( ( KErrNone == error ) );

    const TUint8 err = iNameRecords->RemoveName( name );

    C_TRACE( ( _T( "DISINameService::HandleNameRemoveReq PNS_NAME_REMOVE_RESP name 0x%x err 0x%x" ), name, err ) );

    ASSERT_RESET_ALWAYS( respPtr, ( EISINameServiceNullPointer9 | EDISINameServiceTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( respMsg.Length() > ISI_HEADER_SIZE + PNS_NAME_REMOVE_RESP_OFFSET_REASON ),

                         ( EISINameServiceWrongLength6 | EDISINameServiceTraceId << KClassIdentifierShift ) );

    SetIsiHeaderForResp( respMsg, aPnsNameRemoveReq, PNS_NAME_REMOVE_RESP );

        C_TRACE( ( _T( "DISINameService::HandleNameRemoveReq from own device err 0x%x" ) ) );

        SendToRouter( respMsg );

            TxPnsNameRemoveInd( aPnsNameRemoveReq, name, phonetAddress, flags );

        // No need to send indication if removal did not succeed as state is the same.

        C_TRACE( ( _T( "DISINameService::HandleNameRemoveReq PNS_NAME_REMOVE_REQ from other device not allowed" ) ) );

        SendToRouter( respMsg );

    TDes8* block = reinterpret_cast<TDes8*>( const_cast<TDesC8*>(&aPnsNameRemoveReq) );

    MemApi::DeallocBlock( *block );

    C_TRACE( ( _T( "DISINameService::HandleNameRemoveReq 0x%x<" ), &aPnsNameRemoveReq ) );

void DISINameService::SendToRouter(

        TDes8& aMessage

        )

    C_TRACE( ( _T( "DISINameService::SendToRouter 0x%x>" ), &aMessage ) );

    FreeNameServiceDMutex();

    TInt value = iRouter->Send( aMessage, iObjId );

    ASSERT_RESET_ALWAYS( value == KErrNone, ( EISINameServiceSendFailed | EDISINameServiceTraceId << KClassIdentifierShift ) );

    C_TRACE( ( _T( "DISINameService::SendToRouter 0x%x<" ), &aMessage ) );

    }

void DISINameService::HandlePnsNameMessage( const TDesC8& aMessage )

    {

    C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage 0x%x>" ), &aMessage ) );

            C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage PNS_NAME_QUERY_REQ" ) ) );

            HandleNameQueryReq( aMessage );

            C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage PNS_NAME_ADD_REQ" ) ) );

            HandleNameAddReq( aMessage );

            C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage PNS_NAME_REMOVE_REQ" ) ) );

            HandleNameRemoveReq( aMessage );

            break;

            }

        case COMMON_MESSAGE:

            {

            C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage COMMON_MESSAGE" ) ) );

            HandleCommonMessage( aMessage );

            TRACE_ASSERT_ALWAYS( KAlwaysAssert );

            TDes8& commonMessage = reinterpret_cast<TDes8&>( const_cast<TDesC8&>( aMessage ) );    

            SendCommServiceNotIdentifiedResp( commonMessage );

            C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage unknown NAMESERVICE message" )  ) );

    C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage 0x%x<" ), &aMessage ) );

void DISINameService::HandleNameAddReq(

        const TDesC8& aPnsNameAddReq

        )

    {

    C_TRACE( ( _T( "DISINameService::HandleNameAddReq 0x%x>" ), &aPnsNameAddReq ) );

    TInt err( KErrArgument );

    TUint16 respMsgLength( ISI_HEADER_SIZE + SIZE_PNS_NAME_ADD_RESP );

    TDes8& respMsg = MemApi::AllocBlock( respMsgLength );

    respMsg.SetLength( respMsgLength );

    TUint8* respPtr = const_cast<TUint8*>( respMsg.Ptr() );

    const TUint8* msgPtr = const_cast<TUint8*>( aPnsNameAddReq.Ptr() );

    SetIsiHeaderForResp( respMsg, aPnsNameAddReq, PNS_NAME_ADD_RESP );

    if( msgPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] == PN_DEV_OWN )

        {

        C_TRACE( ( _T( "DISINameService::HandleNameAddReq PNS_NAME_ADD_REQ from this device" ) ) );

        TUint32 name = GETB32( &msgPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY ] );

        TUint16 phonetAddr = GETB16( &msgPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + PN_NAME_SRV_ITEM_STR_OFFSET_DEV ] );

        TUint8 flags = msgPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + PN_NAME_SRV_ITEM_STR_OFFSET_FLAGS ];

        err = iNameRecords->AddName( name, phonetAddr, flags );

        respPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ] = err;

        SendToRouter( respMsg );

        if( err == PN_NAME_OK )

            {

            TxPnsNameAddInd( aPnsNameAddReq, name, phonetAddr, flags );

            }

        // No need for else as state is not changed and indication is not needed to send.

        }

    else

        {

        C_TRACE( ( _T( "DISINameService::HandleNameAddReq PNS_NAME_ADD_REQ from other device" ) ) );

        respPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ] = PN_NAME_NOT_ALLOWED;

        SendToRouter( respMsg );

        }

    TDes8* block = reinterpret_cast<TDes8*>( const_cast<TDesC8*>(&aPnsNameAddReq) );

    MemApi::DeallocBlock( *block );

    C_TRACE( ( _T( "DISINameService::HandleNameAddReq 0x%x<" ), &aPnsNameAddReq ) );

    }

    C_TRACE( ( _T( "MISICommunicationManagerIf::IsValidResource 0x%x>" ), &aMessage ) );

    DISINameService* self = DISINameService::GetISINameServiceF();

    TBool found = self->HandleResourceValidationCheck( aMessage );

    C_TRACE( ( _T( "MISICommunicationManagerIf::IsValidResource 0x%x %d<" ), &aMessage, found ) );

    return found;

EXPORT_C TUint8 MISICommunicationManagerIf::GetDeviceIdentifierByResource(

        const TUint32 aResourceIdentifier

        )

    {

    C_TRACE( ( _T( "MISICommunicationManagerIf::GetDeviceIdentifierByResource 0x%x>" ), aResourceIdentifier ) );

    DISINameService* self = DISINameService::GetISINameServiceF();

    TUint8 deviceIdentifier = self->GetDeviceIdByResource( aResourceIdentifier );

    C_TRACE( ( _T( "MISICommunicationManagerIf::GetDeviceIdentifierByResource 0x%x 0x%x<" ), aResourceIdentifier, deviceIdentifier ) );

    return deviceIdentifier;

    }

    C_TRACE( ( _T( "DISINameService::ConstructCommIsaEntityNotReachableResp 0x%x>" ), &aMsg ) );

    // Transactionid. 

    tempPtr.Append( KFiller );

    tempPtr.Append( KFiller );

    tempPtr.Append( KFiller );

    SendToRouter( tempPtr );

    C_TRACE( ( _T( "DISINameService::SendCommIsaEntityNotReachableResp 0x%x<" ), &aMsg ) );

    }

void DISINameService::HandleCommonMessage(

        const TDesC8& aCommonMessage

        )

    {

    C_TRACE( ( _T( "DISINameService::HandleCommonMessage 0x%x>" ), &aCommonMessage ) );

    TDes8& commonMessage = reinterpret_cast<TDes8&>( const_cast<TDesC8&>(aCommonMessage) );

    const TUint8 subMessageIdentifier = commonMessage.Ptr()[ ISI_HEADER_OFFSET_SUBMESSAGEID ];

    switch( subMessageIdentifier )

        {

        case COMM_ISA_ENTITY_NOT_REACHABLE_RESP:

            {

            const TUint8 notDeliveredMessageIndex = ( ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_ISA_ENTITY_NOT_REACHABLE_RESP_OFFSET_NOTDELIVEREDMESSAGEID );

            const TUint8 notDeliveredMessageIdentifier = commonMessage.Ptr()[ notDeliveredMessageIndex ];

            // If some of name service _RESP worryig behaviour from client. If _IND it does not matter so much, although unsubscription for indications is not working then.

            C_TRACE( ( _T( "DISINameService::HandleCommonMessage COMM_ISA_ENTITY_NOT_REACHABLE_RESP not delivered message 0x%x" ), notDeliveredMessageIdentifier ) );

            TRACE_ASSERT_ALWAYS( KAlwaysAssert );

            // Dellocate here, because this is not sending a reply at all to avoid never ending loop.

            MemApi::DeallocBlock( commonMessage );

            // Signal here because it does not send a reply.

            FreeNameServiceDMutex();

            break;

            }