/*
* Copyright (c) 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:    Represents ICE valid list.
*
*/




#include "natfwcredentials.h"
#include "natfwcandidatepair.h"
#include "natfwcandidate.h"
#include "cicevalidlist.h"
#include "icecandidatehandlerlogs.h"

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

CIceValidList::CIceValidList( TUint aCollectionId )
    :
    iCollectionId( aCollectionId )
    {
    __ICEDP( "CIceValidList::CIceValidList" )
    }
     

CIceValidList* CIceValidList::NewL( TUint aCollectionId )
    {
    __ICEDP( "CIceValidList::NewL" )

    CIceValidList* self 
        = CIceValidList::NewLC( aCollectionId );
    CleanupStack::Pop( self );
    
    return self;
    }


CIceValidList* CIceValidList::NewLC( TUint aCollectionId )
    {
    __ICEDP( "CIceValidList::NewLC" )

    CIceValidList* self 
        = new( ELeave ) CIceValidList( aCollectionId );
    CleanupStack::PushL( self );
    
    return self;
    }
    
  
CIceValidList::~CIceValidList()
    {
    __ICEDP( "CIceValidList::~CIceValidList" )
    
    iValidList.ResetAndDestroy();
    }
    
    
// ---------------------------------------------------------------------------
// CIceValidList::StreamCollectionId
// ---------------------------------------------------------------------------
//
TUint CIceValidList::StreamCollectionId() const
    {
    __ICEDP( "CIceValidList::StreamCollectionId" )
    
    return iCollectionId;
    }


// ---------------------------------------------------------------------------
// CIceValidList::AddValidPairL
// ---------------------------------------------------------------------------
//
void CIceValidList::AddValidPairL( const CNATFWCandidatePair& aPair )
    {
    __ICEDP( "CIceValidList::AddValidPairL" )
    
    // check if existing pair needs to be updated
    TBool existingPairFound( EFalse );
    TInt validPairInd( iValidList.Count() - 1 );
    while ( !existingPairFound && 0 <= validPairInd )
        {
        if ( aPair.LocalCandidate().ComponentId() 
                == iValidList[validPairInd]->LocalCandidate().ComponentId()
            && aPair.Priority() == iValidList[validPairInd]->Priority() )
            {
            existingPairFound = ETrue;
            iValidList[ validPairInd ]->CopyL( aPair );
            }
        
        validPairInd--;
        }
    
    if ( !existingPairFound )
        {
        // add new pair to the valid list
        CNATFWCandidatePair* newPair = CNATFWCandidatePair::NewLC( aPair );
        iValidList.InsertInOrderL( 
            newPair, CNATFWCandidatePair::PriorityOrder );
        CleanupStack::Pop( newPair );
        }
    }


// ---------------------------------------------------------------------------
// CIceValidList::HasPair
// ---------------------------------------------------------------------------
//
TBool CIceValidList::HasPair( const CNATFWCandidatePair& aPair ) const
    {
    __ICEDP( "CIceValidList::HasPair" )
    
    TInt ind = iValidList.Find( &aPair, CNATFWCandidatePair::MatchAddresses );
    return ( KErrNotFound != ind );
    }


// ---------------------------------------------------------------------------
// CIceValidList::HasPairForComponents
// ---------------------------------------------------------------------------
//
TBool CIceValidList::HasPairForComponents( 
        RArray<TUint>& aComponentIds ) const
    {
    __ICEDP( "CIceValidList::HasPairForComponents" )
    
    TInt numOfComponents( aComponentIds.Count() );
    ASSERT( numOfComponents );
    TInt numOfValidPairs( iValidList.Count() );
    
    for ( TInt i( 0 ); i < numOfComponents; ++i )
        {
        TUint compId( aComponentIds[i] );
        
        TBool validPairExists( EFalse );
        for ( TInt j( 0 ); j < numOfValidPairs; j++ )
            {
            if ( iValidList[j]->LocalCandidate().ComponentId() == compId )
                {
                validPairExists = ETrue;
                }
            }
        
        if ( !validPairExists )
            {
            __ICEDP( "CIceValidList::HasPairForComponents, EFalse" )
            return EFalse;
            }
        }
    
    __ICEDP( "CIceValidList::HasPairForComponents, ETrue" )
    return ETrue;
    }


// ---------------------------------------------------------------------------
// CIceValidList::SetPairNominatedL
// ---------------------------------------------------------------------------
//
void CIceValidList::SetPairNominatedL( const CNATFWCandidatePair& aPair )
    {
    __ICEDP( "CIceValidList::SetPairNominatedL" )
    
    TInt ind = iValidList.Find( &aPair, CNATFWCandidatePair::MatchAddresses );
    User::LeaveIfError( ind );
    
    iValidList[ind]->SetSelected( ETrue );
    }


// ---------------------------------------------------------------------------
// CIceValidList::NominatedPairsExist
// ---------------------------------------------------------------------------
//
TBool CIceValidList::NominatedPairsExist( 
        RArray<TUint>& aComponentIds ) const
    {
    __ICEDP( "CIceValidList::NominatedPairsExist" )
    
    TInt ind( aComponentIds.Count() );
    ASSERT( aComponentIds.Count() );
    
    while ( ind-- )
        {
        if ( NULL == SelectedPair( aComponentIds[ind] ) )
            {
            return EFalse;
            }
        }
    
    return ETrue;
    }


// ---------------------------------------------------------------------------
// CIceValidList::SelectedPair
// ---------------------------------------------------------------------------
//
const CNATFWCandidatePair* 
    CIceValidList::SelectedPair( TUint aComponentId ) const
    {
    __ICEDP( "CIceValidList::SelectedPair" )
    
    TInt count( iValidList.Count() );
    for ( TInt i( 0 ); i < count; ++i )
        {
        CNATFWCandidatePair* item( iValidList[i] );
        if ( item->Selected() 
            && item->LocalCandidate().ComponentId() == aComponentId )
            {
            return item;
            }
        }
    
    return NULL;
    }


// ---------------------------------------------------------------------------
// CIceValidList::HighestPriorityPair
// ---------------------------------------------------------------------------
//
const CNATFWCandidatePair* CIceValidList::HighestPriorityPair( 
        TUint aComponentId ) const
    {
    __ICEDP( "CIceValidList::HighestPriorityPair" )
    
    TInt count( iValidList.Count() );
    for ( TInt i( 0 ); i < count; ++i )
        {
        CNATFWCandidatePair* item( iValidList[i] );
        if ( item->LocalCandidate().ComponentId() == aComponentId )
            {
            return item;
            }
        }
    
    return NULL;
    }


// ---------------------------------------------------------------------------
// CIceValidList::FlushValidList
// ---------------------------------------------------------------------------
//
void CIceValidList::FlushValidList()
    {
    __ICEDP( "CIceValidList::FlushValidList" )
    
    iValidList.ResetAndDestroy();
    }