/*

* 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:    

*

*/

#include "natfwcandidate.h"

#include "natfwcandidatepair.h"

#include "cicechecklist.h"

#include "cicecheckprioritizer.h"

#include "cicecandidateprioritizer.h"

#include "ciceconnectivitycheck.h"

#include "cicesessiondata.h"

#include "micechecklistobserver.h"

#include "cicevalidlist.h"

#include "icecandidatehandlerdefs.h"

#include "icecandidatehandlerlogs.h"

const TUint KComponentIdRtp = 1;

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

CIceCheckList::CIceCheckList(

        MIceChecklistObserver& aClient,

        TUint aStreamCollectionId,

        CIceSessionData& aSessionData,

        CIceConnectionHandler& aConnHandler )

    :

    iStreamCollectionId( aStreamCollectionId ),

    iClient( aClient ),

    iSessionData( aSessionData ),

    iConnHandler( aConnHandler )

    {

    }

void CIceCheckList::ConstructL()

    {

    iCheckPrioritizer = CIceCheckPrioritizer::NewL();

    iCandPrioritizer = CIceCandidatePrioritizer::NewL( 

        iSessionData.Domain() );

    iTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iValidList = CIceValidList::NewL( iStreamCollectionId );

    GenerateCheckListL( iChecks );

    }

CIceCheckList* CIceCheckList::NewL(

        MIceChecklistObserver& aClient,

        TUint aStreamCollectionId,

        CIceSessionData& aSessionData,

        CIceConnectionHandler& aConnHandler )

    {

    CIceCheckList* self 

        = CIceCheckList::NewLC( aClient, aStreamCollectionId, 

        aSessionData, aConnHandler );

    CleanupStack::Pop( self );

    return self;

    }

CIceCheckList* CIceCheckList::NewLC(

        MIceChecklistObserver& aClient,

        TUint aStreamCollectionId,

        CIceSessionData& aSessionData,

        CIceConnectionHandler& aConnHandler )

    {

    CIceCheckList* self 

        = new( ELeave ) CIceCheckList( 

        aClient, aStreamCollectionId, aSessionData, aConnHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CIceCheckList::~CIceCheckList()

    {

    __ICEDP( "CIceCheckList::~CIceCheckList" )

    iChecks.ResetAndDestroy();

    iCheckQue.Close();

    delete iCheckPrioritizer;

    delete iCandPrioritizer;

    delete iTimer;

    delete iValidList;

    iComponentIds.Close();

    iSelectedPairs.ResetAndDestroy();

    }

// ---------------------------------------------------------------------------

// CIceCheckList::TimerFired

// ---------------------------------------------------------------------------

//

TInt CIceCheckList::TimerFired( TAny* aObject )

    {

    if ( aObject )

        {

        CIceCheckList* list = reinterpret_cast<CIceCheckList*>( aObject );

        TRAPD( error, list->OnTimerFiredL() )

        if ( error )

            {

            __ICEDP_INT1( "CIceCheckList::TimerFired, ERR:", error )

            if ( KErrNoMemory == error )

                {

                TRAP_IGNORE( list->SetStateL( EIceCheckListFailed ) )

                }

            else

                {

                ASSERT( EFalse );

                }

            }

        return 1;

        }

    else

        {

        __ICEDP( "CIceCheckList::TimerFired, ELSE" )

        ASSERT( EFalse );

        return 0;   // lint #527

        }

    }

// Non-derived function

// ---------------------------------------------------------------------------

// CIceCheckList::State

// ---------------------------------------------------------------------------

//

CIceCheckList::TIceCheckListState CIceCheckList::State() const

    {

    return iState;

    }

// ---------------------------------------------------------------------------

// CIceCheckList::StreamCollectionId()

// ---------------------------------------------------------------------------

//

TUint CIceCheckList::StreamCollectionId() const

    {

    return iStreamCollectionId;

    }

// ---------------------------------------------------------------------------

// CIceCheckList::InitializeCheckListL()

// Used to initialize check list corresponding first SDP mediastream.

// ICE-17, section 5.7.4.

// ---------------------------------------------------------------------------

//

void CIceCheckList::InitializeCheckListL()

    {

    __ICEDP( "CIceCheckList::InitializeCheckListL" )

    __ASSERT_DEBUG( iChecks.Count(), User::Leave( KErrNotReady ) );

    TUint lowestComponentId = LowestComponentId( iComponentIds );

    CDesC8ArrayFlat* foundations 

        = FoundationsForCollectionL( iStreamCollectionId );

    TInt foundationCount( foundations->Count() );

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

        {

        // inside foundation group set lowest component id waiting

        TInt checkIndex( iChecks.Count() );

        TBool checkInitialized( EFalse );

        while ( ( checkIndex-- ) && ( !checkInitialized ) )

            {

            CIceConnectivityCheck& check( *iChecks[checkIndex] );

            if ( check.CandidatePair().Foundation() 

                    == foundations->MdcaPoint(i)

                && check.ComponentId() == lowestComponentId )

                {

                check.Initialize();

                checkInitialized = ETrue;

                }

            }

        }

    delete foundations;

    }

// ---------------------------------------------------------------------------

// CIceCheckList::InitializeCheckListL

// ICE-17, 7.1.2.2.3, Updating Pair States.

// ---------------------------------------------------------------------------

//

void CIceCheckList::InitializeCheckListL( const TDesC8& aFoundation )

    {

    __ICEDP( "CIceCheckList::InitializeCheckListL" )

    __ASSERT_DEBUG( iChecks.Count(), User::Leave( KErrNotReady ) );

    TBool initComplete( EFalse );

    TInt count( iChecks.Count() );

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

        {

        if ( CIceConnectivityCheck::EIceCheckFrozen == iChecks[i]->State()

            && iChecks[i]->CandidatePair().Foundation() == aFoundation )

            {

            iChecks[i]->Initialize();

            initComplete = ETrue;

            }

        }

    if ( !initComplete && CheckListFrozen() )

        {

        InitializeCheckListL();

        }

    }

// ---------------------------------------------------------------------------

// CIceCheckList::StartPerformChecksL()

// ---------------------------------------------------------------------------

//

void CIceCheckList::StartPerformChecksL( 

        const TTimeIntervalMicroSeconds32& anInterval )

    {

    __ICEDP( "CIceCheckList::StartPerformChecksL" )

    iInterval = anInterval;

    SetStateL( EIceCheckListRunning );

    }

// ---------------------------------------------------------------------------

// CIceCheckList::RestartCheckListL()

// ---------------------------------------------------------------------------

//

void CIceCheckList::RestartCheckListL(

        const TTimeIntervalMicroSeconds32& anInterval )

    {

    __ICEDP( "CIceCheckList::RestartCheckListL" )

    __ASSERT_ALWAYS( EIceCheckListCompleted == State(), 

        User::Leave( KErrNotReady ) );

    iValidList->FlushValidList();

    iChecks.ResetAndDestroy();

    GenerateCheckListL( iChecks );

    iInterval = anInterval;

    SetStateL( EIceCheckListRunning );

    }

// ---------------------------------------------------------------------------

// CIceCheckList::UpdateCheckListL()

// Controlling peer has selected candidate pairs to be used.

// ICE-17, 9.2.2.3. Existing Media Streams and remote-candidates.

// ---------------------------------------------------------------------------

//

void CIceCheckList::UpdateCheckListL( 

        RPointerArray<CNATFWCandidatePair>& aPeerSelectedPairs )

    {

    __ICEDP( "CIceCheckList::UpdateIceProcessingL" )

    __ASSERT_DEBUG( EIceCheckListRunning == State(), 

        User::Leave( KErrNotReady ) );

    __ASSERT_ALWAYS( !iSelectedPairs.Count(), 

        User::Leave( KErrAlreadyExists ) );

    TInt numOfSelectedComps( aPeerSelectedPairs.Count() );

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

        {

        CNATFWCandidatePair* pair 

            = CNATFWCandidatePair::NewLC( *aPeerSelectedPairs[i] );

        iSelectedPairs.AppendL( pair );

        CleanupStack::Pop( pair );

        }

    DoLosingPairProcessingL( iSelectedPairs );

    UpdateCheckListStateL();

    }

// ---------------------------------------------------------------------------

// CIceCheckList::UpdateCheckListL()

// Peer has added new remote candidates to the session negotiation.

// ICE-17, 9.3.1.4. ICE Continuing for Existing Media Stream.

// ---------------------------------------------------------------------------

//

void CIceCheckList::UpdateCheckListL( 

        RPointerArray<CNATFWCandidate>& /*aRemoteCands*/ )

    {

    __ICEDP( "CIceCheckList::UpdateIceProcessingL" )

    __ASSERT_DEBUG( EIceCheckListRunning == State(), 

        User::Leave( KErrNotReady ) );

    RPointerArray<CIceConnectivityCheck> newCheckList;

    CleanupResetAndDestroyPushL( newCheckList );

    GenerateCheckListL( newCheckList );

    // Add new checks to the checklist

    for ( TInt i( newCheckList.Count() - 1 ); i >= 0; --i )

        {

        CIceConnectivityCheck* newCheck( newCheckList[i] );

        TInt ind = iChecks.Find( 

            newCheck, CIceConnectivityCheck::MatchAddresses );

        // All new checks are in frozen state initially

        if ( KErrNotFound == ind )

            {

            iChecks.InsertInOrderL( newCheck,

                CIceConnectivityCheck::ComparePriorities );

            newCheckList.Remove( i );

            }

        }

    TBool rtpComponentFound( EFalse );

    TInt ind( iChecks.Count() - 1 );

    while( ( !rtpComponentFound ) && ( 0 <= ind ) )

        {

        if ( KComponentIdRtp == iChecks[ind]->ComponentId()

            && CIceConnectivityCheck::EIceCheckSucceed 

                == iChecks[ind]->State() )

            {

            rtpComponentFound = ETrue;

            InitializeCheckList( 

                iChecks[ind]->CandidatePair().Foundation(), 

                KComponentIdRtp );

            if ( iValidList->HasPairForComponents( iComponentIds ) )

                {

                // Start checks in other check lists for checks of same type

                iClient.ComponentsHaveValidPairsL( 

                    *this, iChecks[ind]->CandidatePair().Foundation() );

                }

            }

        ind--;

        }

    CleanupStack::PopAndDestroy( &newCheckList );

    }

// ---------------------------------------------------------------------------

// CIceCheckList::GenerateCheckListL()

// ---------------------------------------------------------------------------

//

void CIceCheckList::GenerateCheckListL( 

        RPointerArray<CIceConnectivityCheck>& aCheckList )

    {

    __ICEDP( "CIceCheckList::GenerateCheckListL" )

    RPointerArray<CNATFWCandidate> localCandidates;

    RPointerArray<CNATFWCandidate> remoteCandidates;

    CleanupClosePushL( localCandidates );

    CleanupClosePushL( remoteCandidates );

    iSessionData.GetLocalCandidates(

        iStreamCollectionId,

        localCandidates );

    iSessionData.GetRemoteCandidatesL(

        iStreamCollectionId,

        remoteCandidates );

    __ASSERT_ALWAYS( localCandidates.Count() && remoteCandidates.Count(),

        User::Leave( KErrNotReady ) );

    PairCandidatesL( aCheckList, localCandidates, remoteCandidates );

    CleanupStack::PopAndDestroy( &remoteCandidates );

    CleanupStack::PopAndDestroy( &localCandidates );

    iCheckPrioritizer->PrioritizeChecks( aCheckList, iSessionData.Role() );

    aCheckList.Sort( CIceConnectivityCheck::ComparePriorities );

    PruneChecksL( aCheckList );

#ifdef _DEBUG

    __ICEDP( "CIceCheckList::GenerateCheckListL, LIST AFTER PRUNING" )

    TInt count( aCheckList.Count() );

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

        {

        __ICEDP_ADDRLOG( "LOCAL_ADDR", 

            aCheckList[i]->CandidatePair().LocalCandidate().TransportAddr() )

        __ICEDP_ADDRLOG( "PEER_ADDR", 

            aCheckList[i]->CandidatePair().RemoteCandidate().TransportAddr() )

        }

#endif

    GetComponentIdsL( iComponentIds );

    }

// ---------------------------------------------------------------------------

// CIceCheckList::PairCandidatesL

// ---------------------------------------------------------------------------

//

void CIceCheckList::PairCandidatesL(

    RPointerArray<CIceConnectivityCheck>& aCheckList,

    RPointerArray<CNATFWCandidate>& aLocalCands,

    RPointerArray<CNATFWCandidate>& aRemoteCands )

    {

    __ICEDP( "CIceCheckList::PairCandidatesL" )

    CNATFWCandidate* lCand( NULL );

    CNATFWCandidate* rCand( NULL );

    TInt lInd = aLocalCands.Count();

    while ( lInd-- )

        {

        lCand = aLocalCands[lInd];

        TInt rInd = aRemoteCands.Count();

        while ( rInd-- )

            {

            rCand = aRemoteCands[rInd];

            if ( CompatibleCandidates( *lCand, *rCand ) )

                {

                CIceConnectivityCheck* check

                    = CIceConnectivityCheck::NewLC( *this, *lCand, *rCand, 

                    iConnHandler, iSessionData );

                aCheckList.AppendL( check );

                CleanupStack::Pop( check );

                }

            }

        }

    }

// ---------------------------------------------------------------------------

// CIceCheckList::CompatibleCandidates

// According to ICE-17, 5.7.1. and ICE-TCP-03, 4.1.

// ---------------------------------------------------------------------------

//

TBool CIceCheckList::CompatibleCandidates( 

        const CNATFWCandidate& aCand1, const CNATFWCandidate& aCand2 ) const

    {

    __ICEDP( "CIceCheckList::CompatibleCandidates" )

    TUint protocol( aCand1.TransportProtocol() );

    if ( protocol != aCand2.TransportProtocol()

        || aCand1.TransportAddr().Family() != aCand2.TransportAddr().Family()

        || aCand1.ComponentId() != aCand2.ComponentId() )

        {

        return EFalse;

        }

    if ( KProtocolInetUdp == protocol )

        {

        return ETrue;

        }

    else

        {

        // we have not TCP support yet

        return EFalse;

        }

    }

// ---------------------------------------------------------------------------

// CIceCheckList::PruneChecksL

// ICE-17, 5.7.3 Pruning the pairs.

// Procedures of ICE-TCP-03, 4.1. to be added.

// ---------------------------------------------------------------------------

//

void CIceCheckList::PruneChecksL( 

        RPointerArray<CIceConnectivityCheck>& aChecks )

    {

    __ICEDP_INT1( "CIceCheckList::PruneChecksL start, COUNT:", aChecks.Count() )

    // Replace server reflexive local candidate of the check by corresponding

    // base candidate.

    ReplaceReflexiveCandidatesWithBaseL( aChecks );

    // Remove redundant checks.

    for ( TInt i( aChecks.Count() - 1 ); 0 <= i; --i )

        {

        TInt matchInd = aChecks.Find( aChecks[i],

            CIceConnectivityCheck::MatchAddresses );

        if ( KErrNotFound != matchInd && matchInd != i )

            {

            delete aChecks[i];

            aChecks.Remove( i );

            }

        }

    __ICEDP_INT1( "CIceCheckList::PruneChecksL end, COUNT:", aChecks.Count() )

    }

// ---------------------------------------------------------------------------

// CIceCheckList::ReplaceReflexiveCandidatesWithBaseL

// ---------------------------------------------------------------------------

//

void CIceCheckList::ReplaceReflexiveCandidatesWithBaseL( 

        RPointerArray<CIceConnectivityCheck>& aChecks )

    {

    for ( TInt i( aChecks.Count() - 1 ); i >= 0; --i )

        {

        CNATFWCandidate& localCand = const_cast<CNATFWCandidate&>

            ( aChecks[ i ]->CandidatePair().LocalCandidate() );

        if ( CNATFWCandidate::EServerReflexive == localCand.Type() )

            {

            TInt numOfChecks( aChecks.Count() );

            for ( TInt j( 0 ); j < numOfChecks; ++j )

                {

                const CNATFWCandidate& baseCand

                     = aChecks[ j ]->CandidatePair().LocalCandidate();

                if ( CNATFWCandidate::EHost == baseCand.Type()

                    && TIceUtils::MatchAddresses( 

                        localCand.Base(), baseCand.Base() ) )

                    {