/*
* Copyright (c) 2005-2007 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:   Capability Exchange
*
*/


#include "musavacapabilityexchange.h"
#include <uri8.h>
#include <sipservertransaction.h>
#include <sipclienttransaction.h>
#include <sipresponseelements.h>
#include <sipextensionheader.h>
#include <sipstrings.h>
#include <sipstrconsts.h>


#include "muslogger.h"
#include "musavaterminal.h"
#include "musavacapability.h"
#include "musavacapabilitycontext.h"

// --------------------------------------------------------------------------
// Symbian two-phase constructor
// --------------------------------------------------------------------------
//
CMusAvaCapabilityExchange* CMusAvaCapabilityExchange::NewL( 
                            const TDesC8& aTerminalId,
                            MMusAvaCapabilityQueryObserver& aQueryObserver )
    {
    MUS_LOG( "mus: [MUSAVA] -> CMusAvaCapabilityExchange::NewL" )
    CMusAvaCapabilityExchange* self = 
        new (ELeave) CMusAvaCapabilityExchange( aQueryObserver );
    CleanupStack::PushL( self );
    self->ConstructL( aTerminalId );
    CleanupStack::Pop( self );
    MUS_LOG( "mus: [MUSAVA] <- CMusAvaCapabilityExchange::NewL" )
    return self;
    }


// --------------------------------------------------------------------------
// C++ destructor
// --------------------------------------------------------------------------
//
CMusAvaCapabilityExchange::~CMusAvaCapabilityExchange()
    {
    MUS_LOG( 
    "mus: [MUSAVA] -> CMusAvaCapabilityExchange::~CMusAvaCapabilityExchange" )

    delete iTerminalId;
    iTerminals.ResetAndDestroy();
    iCapabilities.ResetAndDestroy();
    
    MUS_LOG( 
    "mus: [MUSAVA] <- CMusAvaCapabilityExchange::~CMusAvaCapabilityExchange" )
    }


// --------------------------------------------------------------------------
// C++ constructor
// --------------------------------------------------------------------------
//
CMusAvaCapabilityExchange::CMusAvaCapabilityExchange( 
    MMusAvaCapabilityQueryObserver& aQueryObserver )
    : iQueryObserver( aQueryObserver )
    {
    }


// --------------------------------------------------------------------------
// Symbian second-phase constructor
// --------------------------------------------------------------------------
//
void CMusAvaCapabilityExchange::ConstructL( const TDesC8& aTerminalId )
    {
    MUS_LOG( "mus: [MUSAVA] -> CMusAvaCapabilityExchange::ConstructL" )

    iTerminalId = aTerminalId.AllocL();

    MUS_LOG( "mus: [MUSAVA] <- CMusAvaCapabilityExchange::ConstructL" )
    }


// --------------------------------------------------------------------------
// CMusAvaCapabilityExchange::QueryObserver
// --------------------------------------------------------------------------
//
MMusAvaCapabilityQueryObserver& 
                            CMusAvaCapabilityExchange::QueryObserver() const
    {
    return iQueryObserver;
    }


// --------------------------------------------------------------------------
// CMusAvaCapabilityExchange::TerminalId
// --------------------------------------------------------------------------
//
const TDesC8& CMusAvaCapabilityExchange::TerminalId() const
    {
    return *iTerminalId;
    }


// --------------------------------------------------------------------------
// CMusAvaCapabilityExchange::AnswerToQueryReceived
// --------------------------------------------------------------------------
//
void CMusAvaCapabilityExchange::AnswerToQueryReceived( 
                                    const CSIPClientTransaction& aResponse )
    {
    MUS_LOG( 
    "mus: [MUSAVA] -> CMusAvaCapabilityExchange::AnswerToQueryReceived" )
    
    TInt error = KErrNone;
    CMusAvaTerminal* terminal = NULL;
    TInt index = 0;
    
    while( !terminal && index < iTerminals.Count() )
        {
        terminal = iTerminals[ index++ ];
        TRAP( error, terminal = terminal->QueryCompletedL( aResponse ) ? 
                     terminal : NULL );
        terminal = error != KErrNone ? NULL : terminal;
        }
    
    MUS_LOG( 
    "mus: [MUSAVA] <- CMusAvaCapabilityExchange::AnswerToQueryReceived" )
    }


// --------------------------------------------------------------------------
// CMusAvaCapabilityExchange::QueryReceived
// --------------------------------------------------------------------------
//
void CMusAvaCapabilityExchange::QueryReceived( 
                                            CSIPServerTransaction* aQuery )
    {
    MUS_LOG( "mus: [MUSAVA] -> CMusAvaCapabilityExchange::QueryReceived" )
    
    TRAPD( error, DoQueryReceivedL( *aQuery ) );

    if ( error != KErrNone )
        {
        TRAP_IGNORE( RejectQueryL( *aQuery, error ) )
        }
        
    delete aQuery;
    
    MUS_LOG( "mus: [MUSAVA] <- CMusAvaCapabilityExchange::QueryReceived" )
    }


// --------------------------------------------------------------------------
// CMusAvaCapabilityExchange::CancelQuery
// --------------------------------------------------------------------------
//
void CMusAvaCapabilityExchange::CancelQuery( TInt /*aError*/, 
                                const CSIPClientTransaction& aTransaction )
    {
    MUS_LOG( "mus: [MUSAVA] -> CMusAvaCapabilityExchange::CancelQuery" )

    CMusAvaTerminal* terminal = NULL;
    TInt index = 0;
    
    while( !terminal && index < iTerminals.Count() )
        {
        terminal = iTerminals[ index++ ];
        terminal = terminal->QueryCanceled( aTransaction ) ? 
            terminal : NULL;
        }
    
    MUS_LOG( "mus: [MUSAVA] <- CMusAvaCapabilityExchange::CancelQuery" )
    }


// --------------------------------------------------------------------------
// CMusAvaCapabilityExchange::AddCapabilityL
// --------------------------------------------------------------------------
//
void CMusAvaCapabilityExchange::AddCapabilityL( 
                                        CMusAvaCapability* aCapability )
    {
    MUS_LOG( "mus: [MUSAVA] -> CMusAvaCapabilityExchange::AddCapabilityL" )
    
    User::LeaveIfError( iCapabilities.Find( aCapability ) < KErrNone ?
                        KErrNone : KErrArgument );

    User::LeaveIfError( FindByFeature( *aCapability ) < KErrNone ?
                        KErrNone : KErrArgument );
                        
    iCapabilities.AppendL( aCapability );
    
    MUS_LOG( "mus: [MUSAVA] <- CMusAvaCapabilityExchange::AddCapabilityL" )
    }


// --------------------------------------------------------------------------
// CMusAvaCapabilityExchange::Terminals
// --------------------------------------------------------------------------
//
const RPointerArray<CMusAvaTerminal>& CMusAvaCapabilityExchange::Terminals()
    {
    return iTerminals;
    }

    
// --------------------------------------------------------------------------
// CMusAvaCapabilityExchange::Capabilities
// --------------------------------------------------------------------------
//
const RPointerArray<CMusAvaCapability>& 
                                    CMusAvaCapabilityExchange::Capabilities()
    {
    return iCapabilities;
    }


// --------------------------------------------------------------------------
// CMusAvaCapabilityExchange::TerminalL
// --------------------------------------------------------------------------
//
CMusAvaTerminal& CMusAvaCapabilityExchange::TerminalL( 
                                                const TDesC8& aRemoteUri )
    {
    CMusAvaTerminal* terminal = NULL;
    TInt index = 0;

    while ( !terminal && index < Terminals().Count() )
        {
        terminal = Terminals()[ index++ ];
        terminal = terminal->MatchL( aRemoteUri ) ? terminal : NULL;
        }
    
    if ( !terminal )
        {
        terminal = CMusAvaTerminal::NewL( *this, aRemoteUri, KNullDesC8 );
        CleanupStack::PushL( terminal );
        iTerminals.AppendL( terminal );
        CleanupStack::Pop( terminal );
        }

    return *terminal;
    }


// --------------------------------------------------------------------------
// CMusAvaCapabilityExchange::TerminalL
// --------------------------------------------------------------------------
//
CMusAvaTerminal& CMusAvaCapabilityExchange::TerminalL( 
                                        const CSIPServerTransaction& aQuery )
    {
    CMusAvaTerminal* terminal = NULL;
    
    const CSIPExtensionHeader* userAgent = 
                        MusAvaCapabilityContext::UserAgentHeaderL( aQuery );
    const CUri8& originator = MusAvaCapabilityContext::OriginatorL( aQuery );
    
    const TDesC8& terminalUri = originator.Uri().UriDes();
    const TDesC8& terminalId = userAgent ? userAgent->Value() : KNullDesC8;
    
    TInt index = 0;
    while( !terminal && index < Terminals().Count() )
        {
        terminal = Terminals()[ index++ ];
        terminal = terminal->MatchL( terminalUri, terminalId )
                   ? terminal : NULL;
        }
    
    if ( !terminal )
        {
        terminal = CMusAvaTerminal::NewL( *this, terminalUri, terminalId );
        CleanupStack::PushL( terminal );
        iTerminals.AppendL( terminal );
        CleanupStack::Pop( terminal );
        }
        
    return *terminal;
    }


// --------------------------------------------------------------------------
// CMusAvaCapabilityExchange::DoQueryReceivedL
// --------------------------------------------------------------------------
//
void CMusAvaCapabilityExchange::DoQueryReceivedL( 
                                            CSIPServerTransaction& aQuery )
    {
    MUS_LOG( 
        "mus: [MUSAVA] -> CMusAvaCapabilityExchange::DoQueryReceivedL" )
    
    CMusAvaTerminal& terminal = TerminalL( aQuery );
    
    terminal.QueryRequestedL( aQuery );
    
    MUS_LOG( 
        "mus: [MUSAVA] <- CMusAvaCapabilityExchange::DoQueryReceivedL" )
    }


// --------------------------------------------------------------------------
// CMusAvaCapabilityExchange::RejectQueryL
// --------------------------------------------------------------------------
//
void CMusAvaCapabilityExchange::RejectQueryL( CSIPServerTransaction& aQuery,
                                            TInt aError )
    {
    MUS_LOG( "mus: [MUSAVA] -> CMusAvaCapabilityExchange::RejectQueryL" )
    TInt statusCode = aError < 0 ? KMUSAVASIPServerInternalError : aError;
    RStringF reasonPhrase = 
            statusCode == KMUSAVASIPServerInternalError ?
            SIPStrings::StringF( SipStrConsts::EPhraseServerInternalError ):
            SIPStrings::StringF( SipStrConsts::EEmpty);

    CSIPResponseElements* response = 
        CSIPResponseElements::NewLC( statusCode, reasonPhrase );
        
    aQuery.SendResponseL( response );
    
    CleanupStack::Pop( response );
    
    MUS_LOG( "mus: [MUSAVA] <- CMusAvaCapabilityExchange::RejectQueryL" )
    }


// --------------------------------------------------------------------------
// CMusAvaCapabilityExchange::FindByFeature
// --------------------------------------------------------------------------
//
TInt CMusAvaCapabilityExchange::FindByFeature( 
                                        CMusAvaCapability& aCapability )
    {
    TInt index = KErrNotFound;
    CMusAvaCapability* capability = NULL;
    
    for ( TInt i=0; i < iCapabilities.Count() && index == KErrNotFound; i++ )
        {
        capability = iCapabilities[i];
        if ( capability->Feature() == aCapability.Feature() )
            {
            index = i;
            }
        }
    return index;
    }