// Copyright (c) 2006-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:
// Name          : CSipAcceptContactStrategy.cpp
// Part of       : SIP Client Resolver
// Version       : 1.0
//



#include "CSipAcceptContactStrategy.h"
#include "MSipClients.h"
#include "MSipClient.h"
#include "sipresponse.h"
#include "siprequest.h"
#include "sipacceptcontactheader.h"
#include "CSIPFeatureSet.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "TSIPClientScore.h"
#include "SIPCRLogs.h"
	
const TUint K480ResponseCode = 480;


// ----------------------------------------------------------------------------
// CSipAcceptContactStrategy::NewL
// ----------------------------------------------------------------------------
//
CSipAcceptContactStrategy* CSipAcceptContactStrategy::NewL(
    MSipClients& aSipClients,
    CSipHeaderStrategyBase* aNextStrategy,
    CSipHeaderStrategyBase* aNextStrategy2 )
	{
	CSipAcceptContactStrategy* self = 
		CSipAcceptContactStrategy::NewLC( aSipClients,
										  aNextStrategy,
										  aNextStrategy2 );
	CleanupStack::Pop(self);
	return self;
	}

// ----------------------------------------------------------------------------
// CSipAcceptContactStrategy::NewLC
// ----------------------------------------------------------------------------
//
CSipAcceptContactStrategy* CSipAcceptContactStrategy::NewLC(
    MSipClients& aSipClients,
    CSipHeaderStrategyBase* aNextStrategy,
    CSipHeaderStrategyBase* aNextStrategy2 )
	{
	CSipAcceptContactStrategy* self = 
		new(ELeave)CSipAcceptContactStrategy( aSipClients,
											 aNextStrategy,
											 aNextStrategy2 );
	CleanupStack::PushL(self);
	return self;
	}

// ----------------------------------------------------------------------------
// CSipAcceptContactStrategy::CSipAcceptContactStrategy
// ----------------------------------------------------------------------------
//
CSipAcceptContactStrategy::CSipAcceptContactStrategy(
    MSipClients& aSipClients,
    CSipHeaderStrategyBase* aNextStrategy,
    CSipHeaderStrategyBase* aNextStrategy2 ) 
 : CSipHeaderStrategyBase( aSipClients,aNextStrategy,aNextStrategy2 )
	{
	iAcceptContactHeaderName = 
	    SIPStrings::StringF(SipStrConsts::EAcceptContactHeader);
	}

// ----------------------------------------------------------------------------
// CSipAcceptContactStrategy::~CSipAcceptContactStrategy
// ----------------------------------------------------------------------------
//
CSipAcceptContactStrategy::~CSipAcceptContactStrategy ()
	{
	}

// ----------------------------------------------------------------------------
// CSipAcceptContactStrategy::ApplyL
// ----------------------------------------------------------------------------
//
CSIPResponse* CSipAcceptContactStrategy::ApplyL(
    CSIPRequest& aRequest, 
    RArray<TUid>& aUids,
    TBool& aContinueSearch,
    CSIPClientResolver2& aClientResolver2 )
	{
	SIP_CR_LOG("CSipAcceptContactStrategy::ApplyL")
	CSIPResponse* response = NULL;
	// The strategy is applied only for requests that contain Accept-Contact
	if (aRequest.HasHeader(iAcceptContactHeaderName))
        {
        RArray<TSIPClientScore> scores(1);
        CleanupClosePushL(scores);
        RPointerArray<CSIPFeatureSet> requestFeatureSets = 
            CreateFeatureSetsL(aRequest);
        TCleanupItem cleanupItem(DestroyFeatureSets,&requestFeatureSets);
	    CleanupStack::PushL(cleanupItem);
	    for (TInt i=0; i < aUids.Count(); i++)
		    {
		    TUid uid(aUids[i]);
		    MSipClient* client = iSipClients.GetByUID(uid);
		    if (client)
			    {
			    TInt score = CalculateScore(*client,requestFeatureSets);
			    if (score > 0)
			        {
			        TSIPClientScore clientScore(score,uid);
			        // The score is used as a key
			        scores.InsertInSignedKeyOrderAllowRepeatsL(clientScore);
			        }
			    }	
		    }
    	CleanupStack::PopAndDestroy(1); // cleanupItem
    	TInt clientCount = scores.Count();
    	aUids.Reset(); // empties the array
	    if (clientCount > 0)
	        {
	        // The scores are in increasing order. 
	        // The last is the best match. Reverse the order.
	        for (TInt i=scores.Count()-1; i>=0; i--)
	            {
	            // In the resulting array the first is the best match
	            aUids.AppendL(scores[i].iUid);
	            } 
	        if (iNextStrategy && clientCount > 1)
	            {
	            // Apply the next strategy only if 
	            // there are still more than one matching clients.
	            response = iNextStrategy->ApplyL(aRequest,aUids,
	                                             aContinueSearch,
	                                             aClientResolver2);
	            }
	        }
	    else
		    {
		    if ( iNextStrategy2 )
		    	{
		    	response = iNextStrategy2->ApplyL(aRequest,aUids,
		    									  aContinueSearch,
		    									  aClientResolver2);
		    	}
		    else
		    	{
		    	response = CreateResponseL();
		    	}
		    
		    }
		CleanupStack::PopAndDestroy(1); // scores
        }
    else
        {
        if (iNextStrategy)
            {
	        response = iNextStrategy->ApplyL(aRequest,aUids,aContinueSearch,
	        												aClientResolver2);
	        }
        }

    return response;
	}

// ----------------------------------------------------------------------------
// CSipAcceptContactStrategy::CreateResponseL
// ----------------------------------------------------------------------------
//
CSIPResponse* CSipAcceptContactStrategy::CreateResponseL()
    {
    return CSIPResponse::NewL(K480ResponseCode,
        SIPStrings::StringF(SipStrConsts::EPhraseTemporarilyNotAvailable));
    }

// ----------------------------------------------------------------------------
// CSipAcceptContactStrategy::CompareHeaders
// ----------------------------------------------------------------------------
//
TBool CSipAcceptContactStrategy::CompareHeaders(
    CSIPRequest& /*aRequest*/,
    MSipClient& /*aClient*/)
	{
	// Not implemented for this sub-class
	return EFalse;
	}

// ----------------------------------------------------------------------------
// CSipAcceptContactStrategy::CreateFeatureSetsL
// ----------------------------------------------------------------------------
//
RPointerArray<CSIPFeatureSet> CSipAcceptContactStrategy::CreateFeatureSetsL(
    CSIPRequest& aRequest)
    {
    RPointerArray<CSIPFeatureSet> featureSets;
    TCleanupItem cleanupItem(DestroyFeatureSets,&featureSets);
	CleanupStack::PushL(cleanupItem);
	TSglQueIter<CSIPHeaderBase> iter = 
	    aRequest.Headers(iAcceptContactHeaderName);	
	while (iter)
		{
		CSIPHeaderBase* tmp = iter++;
		CSIPAcceptContactHeader* acceptContact = 
		    static_cast<CSIPAcceptContactHeader*>(tmp);
		CSIPFeatureSet* featureSet = CSIPFeatureSet::NewLC(*acceptContact);
		featureSets.AppendL(featureSet);
		CleanupStack::Pop(featureSet);
		}	
	CleanupStack::Pop(1); // cleanupItem 
    return featureSets;
    }

// ----------------------------------------------------------------------------
// CSipAcceptContactStrategy::CalculateScore
// ----------------------------------------------------------------------------
//	
TInt CSipAcceptContactStrategy::CalculateScore(
    MSipClient& aClient,
    const RPointerArray<CSIPFeatureSet>& aRequestFeatureSets) const
    {
    TInt score = 0;
    CSIPFeatureSet& clientFeatureSet = aClient.SIPFeatureSet();
    for (TInt i = 0; i < aRequestFeatureSets.Count(); i++)
        {
        CSIPFeatureSet& requestFeatureSet = *aRequestFeatureSets[i];
        TInt tmp = clientFeatureSet.CalculateScore(requestFeatureSet);
        if (tmp == 0 && requestFeatureSet.Require())
            {
            return 0;
            }
        score += tmp;
        }
    return score;
    }
    
// -----------------------------------------------------------------------------
// CSipAcceptContactStrategy::DestroyFeatureSets
// -----------------------------------------------------------------------------
//
void CSipAcceptContactStrategy::DestroyFeatureSets(TAny* aFeatureSets)
	{
    RPointerArray<CSIPFeatureSet>* featureSets =
        reinterpret_cast<RPointerArray<CSIPFeatureSet>*>(aFeatureSets);
    if (featureSets)
        {
        featureSets->ResetAndDestroy();
        }
	}