/*
* Copyright (c) 2009 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:  implementation of sipimresolver
*
*/


#include <spentry.h>
#include <spproperty.h>
#include <spsettings.h>
#include <sdpmediafield.h>

#include "sipimresolver.h"
#include "csipclientresolverutils.h"
#include "sipimresolverdebug.h"

// media field descriptors
_LIT8( KIMField1, "m=application 0 TCP SIPIM\r\n" );
// For content-type header
_LIT8( KIMContentType, "text/plain" );
// For content-type header checks
_LIT8( KIMMediaTypeApp, "text" );
// SDP media subtype
_LIT8( KIMMediaSubtypeSdp, "plain" );

// ======== LOCAL FUNCTIONS ========

// ---------------------------------------------------------------------------
// CleanupSdpMediasArray
// ---------------------------------------------------------------------------
//
void CleanupSdpMediasArray( TAny* aObj )
    {
    if ( aObj )
        {
        static_cast<RPointerArray<CSdpMediaField>*>( aObj )->
            ResetAndDestroy();
        }
    }

// ---------------------------------------------------------------------------
// CleanupSipContentTypeHeaderArray
// ---------------------------------------------------------------------------
//
void CleanupSipContentTypeHeaderArray( TAny* aObj )
    {
    if ( aObj )
        {
        static_cast<RPointerArray<CSIPContentTypeHeader>*>( aObj )->
            ResetAndDestroy();
        }
    }


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


// ---------------------------------------------------------------------------
// CSipImResolver::CSipImResolver
// ---------------------------------------------------------------------------
//
CSipImResolver::CSipImResolver() 
    {
    }

// ---------------------------------------------------------------------------
// CSipImResolver::NewL
// ---------------------------------------------------------------------------
//
CSipImResolver* CSipImResolver::NewL()
	{
	SIPIMRLOG( "[SIPIMRESOLVER] -> CSipImResolver::NewL()" )
	CSipImResolver* self = new ( ELeave ) CSipImResolver;
	return self;
	}

// ---------------------------------------------------------------------------
// CSipImResolver::~CSipImResolver
// ---------------------------------------------------------------------------
//
CSipImResolver::~CSipImResolver()
	{
    SIPIMRLOG( "[SIPIMRESOLVER] -> CSipImResolver::~CSipImResolver()" )
	}

// ---------------------------------------------------------------------------
// From class CSIPResolvedClient2
// CSipImResolver::MatchAcceptContactsL
// ---------------------------------------------------------------------------
//
TBool CSipImResolver::MatchAcceptContactsL(
    RStringF /*aMethod*/,
    const CUri8& /*aRequestUri*/,
    const RPointerArray<CSIPHeaderBase>& /*aHeaders*/,
    const TDesC8& /*aContent*/,
    const CSIPContentTypeHeader* /*aContentType*/,
    TUid& /*aClientUid*/ )
    {
    return EFalse;
    }

// ---------------------------------------------------------------------------
// From class CSIPResolvedClient2
// CSipImResolver::MatchEventL
// ---------------------------------------------------------------------------
// 
TBool CSipImResolver::MatchEventL(
    RStringF /*aMethod*/,
    const CUri8& /*aRequestUri*/,
    const RPointerArray<CSIPHeaderBase>& /*aHeaders*/,
    const TDesC8& /*aContent*/,
    const CSIPContentTypeHeader* /*aContentType*/,
    TUid& /*aClientUid*/)
    {
    return EFalse;
    }

// ---------------------------------------------------------------------------
// From class CSIPResolvedClient2
// CSIPImResolver::MatchRequestL
// ---------------------------------------------------------------------------
// 
TBool CSipImResolver::MatchRequestL(
    RStringF /*aMethod*/,
    const CUri8& aRequestUri,
    const RPointerArray<CSIPHeaderBase>& /*aHeaders*/,
    const TDesC8& aContent,
    const CSIPContentTypeHeader* aContentType,
    TUid& aClientUid )
    {
    SIPIMRLOG( "[SIPIMRESOLVER] MatchRequetsL() IN" )
    
    aClientUid.iUid = 0;
    RArray<TInt> callProviderIds;
    CleanupClosePushL( callProviderIds );
    
    TBool match( EFalse );
    TBool imrequest = ( aContent.Length() > 0 && aContentType &&
        aContentType->MediaType().CompareF( KIMMediaTypeApp ) == 0 &&
        aContentType->MediaSubtype().CompareF( KIMMediaSubtypeSdp ) == 0 );
    
    if( imrequest )
        {
        CSPSettings* spSettings = CSPSettings::NewLC();
        CSPProperty* property = CSPProperty::NewLC();
        
        RArray<TUint> serviceIds;
        CleanupClosePushL( serviceIds );
        spSettings->FindServiceIdsL( serviceIds );
        
        for( TInt i( 0 ) ; i < serviceIds.Count() ; i++ )
            {
            TInt err = spSettings->FindPropertyL( 
                serviceIds[ i ],
                EPropertyCallProviderPluginId,
                *property );
            
            if ( !err )
                {
                TInt callProviderId( 0 );
                err = property->GetValue( callProviderId );
                
                if ( !err )
                    {
                    callProviderIds.AppendL( callProviderId );
                    }
                }
            }
        
        CleanupStack::PopAndDestroy( &serviceIds );
        CleanupStack::PopAndDestroy( property );
        CleanupStack::PopAndDestroy( spSettings ); 
        
        CSipClientResolverUtils* resolver = CSipClientResolverUtils::NewLC();
                
        RArray<TUid> uids;
        CleanupClosePushL( uids );
        
        TRAPD( err, resolver->GetAllImplementationUidsWithUserL(
            aRequestUri.Uri().Extract( EUriUserinfo ), uids ) );
        if ( KErrNotFound != err && KErrNone != err )
            {
            User::Leave( err );
            }
        TInt imProviderId( KErrNotFound );
        for ( TInt j( 0 ) ; j < uids.Count() ; j++ )
            {
            TInt ret = callProviderIds.Find( uids[ j ].iUid );
            
            if ( KErrNotFound == ret )
                {
                imProviderId = uids[ j ].iUid;
                break;
                }         
            }
        
        CleanupStack::PopAndDestroy( &uids );
        CleanupStack::PopAndDestroy( resolver );
        
        if ( !err && ( KErrNotFound != imProviderId ) )
            {
            aClientUid.iUid = imProviderId;
            match = ETrue;
            }
        }
    
    CleanupStack::PopAndDestroy( &callProviderIds );
    
    SIPIMRLOGP( "[SIPIMRESOLVER] MatchRequetsL() match = %d", match  )
    SIPIMRLOGP( "[SIPIMRESOLVER] MatchRequetsL() client uid = %d", aClientUid.iUid  )
  
    return match; 
    }

// ---------------------------------------------------------------------------
// From class CSIPResolvedClient2
// CSIPImResolver::ConnectSupported
// ---------------------------------------------------------------------------
// 
TBool CSipImResolver::ConnectSupported()
    {
    return EFalse;
    }

// ---------------------------------------------------------------------------
// From class CSIPResolvedClient2
// CSIPImResolver::ConnectL
// ---------------------------------------------------------------------------
//
void CSipImResolver::ConnectL( const TUid& /*aClientUid*/ )
    {
    // do nothing
    }

// ---------------------------------------------------------------------------
// From class CSIPResolvedClient2
// CSIPImResolver::CancelConnect
// ---------------------------------------------------------------------------
// 
void CSipImResolver::CancelConnect( const TUid& /*aClientUid*/ )
    {
    // do nothing
    }

// ---------------------------------------------------------------------------
// From class CSIPResolvedClient2
// CSIPImResolver::SupportedContentTypesL
// ---------------------------------------------------------------------------
// 
RPointerArray<CSIPContentTypeHeader> CSipImResolver::SupportedContentTypesL()
    {
    SIPIMRLOG( "[SIPIMRESOLVER] -> CSipImResolver::SupportedContentTypesL()" )

    RPointerArray<CSIPContentTypeHeader> ret;   
    TCleanupItem tci( CleanupSipContentTypeHeaderArray, &ret );
    
    CleanupStack::PushL( tci );
    CSIPContentTypeHeader* ctype = CSIPContentTypeHeader::DecodeL(
        KIMContentType );
    ret.AppendL( ctype );
    CleanupStack::Pop( ); // TCleanupItem

    SIPIMRLOG( "[SIPIMRESOLVER] <- CSipImResolver::SupportedContentTypesL()" )
    return ret;
    }

// ---------------------------------------------------------------------------
// From class CSIPResolvedClient2
// CSIPImResolver::SupportedSdpMediasL
// ---------------------------------------------------------------------------
// 
RPointerArray<CSdpMediaField> CSipImResolver::SupportedSdpMediasL()
    {
    SIPIMRLOG( "[SIPIMRESOLVER] -> CSipImResolver::SupportedSdpMediasL()" )
    
    // Initialise return array
    RPointerArray<CSdpMediaField> ret;
    TCleanupItem tci( CleanupSdpMediasArray, &ret );
    CleanupStack::PushL( tci );  
    
    CSdpMediaField* field = CSdpMediaField::DecodeLC( KIMField1 );
    ret.AppendL( field );
    CleanupStack::Pop( field );    
    
    CleanupStack::Pop( ); // TCleanupItem

    SIPIMRLOG( "[SIPIMRESOLVER] <- CSipImResolver::SupportedSdpMediasL()" )
    return ret;
    }

// ---------------------------------------------------------------------------
// From class CSIPResolvedClient2
// CSIPImResolver::AddClientSpecificHeadersForOptionsResponseL
// ---------------------------------------------------------------------------
// 
void CSipImResolver::AddClientSpecificHeadersForOptionsResponseL(
    RPointerArray<CSIPHeaderBase>& /*aHeaders*/ )
    {
    // do nothing
    }