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




#ifndef C_CICECHECKLIST_H
#define C_CICECHECKLIST_H

#include <e32base.h>
#include <badesca.h>
#include "miceconnchecklistener.h"
#include "ticecheckqueitem.h"
#include "natfwinternaldefs.h"    //UNIT_TEST

class CIceConnectivityCheck;
class CIceCheckPrioritizer;
class CIceSessionData;
class CNATFWCandidate;
class CNATFWCandidatePair;
class CIceCandidatePrioritizer;
class MIceChecklistObserver;
class CIceConnectionHandler;
class TInetAddr;
class CIceValidList;

/**
 *  ICE check list for a stream collection (e.g. SDP media stream).
 *
 *  @lib icecandidatehandler.dll
 *  @since S60 v3.2
 */
class CIceCheckList : public CBase, public MIceConnCheckListener
    {

    UNIT_TEST( UT_CIceCheckList )
    UNIT_TEST( UT_CIceCheckHandler )
    
public:

    /**  ICE check list states */
    enum TIceCheckListState
        {
        EIceCheckListRunning        = 1,
        EIceCheckListCompleted      = 2,
        EIceCheckListFailed         = 3
        };

    /**
     * Two-phased constructor.
     * @param   aClient                 The client
     * @param   aStreamCollectionId     The stream collection
     * @param   aSessionData            The session data
     * @param   aConnHandler            The connection handler
     */
    static CIceCheckList* NewL( 
        MIceChecklistObserver& aClient,
        TUint aStreamCollectionId,
        CIceSessionData& aSessionData,
        CIceConnectionHandler& aConnHandler );

    /**
     * Two-phased constructor.
     * @param   aClient                 The client
     * @param   aStreamCollectionId     The stream collection
     * @param   aSessionData            The session data
     * @param   aConnHandler            The connection handler
     */
    static CIceCheckList* NewLC( 
        MIceChecklistObserver& aClient,
        TUint aStreamCollectionId,
        CIceSessionData& aSessionData,
        CIceConnectionHandler& aConnHandler );

    /**
     * Destructor.
     */
    virtual ~CIceCheckList();

    /**
     * For usage with CPeriodic.
     */
    static TInt TimerFired( TAny* aObject );

    /**
     * Return state of the checklist.
     * 
     * @since   S60 v3.2
     * @return  Sate of the checklist
     */
    TIceCheckListState State() const;

    /**
     * Returns stream collection id for the check list.
     * 
     * @since   S60 v3.2
     * @return  Stream collection identifier
     */
    TUint StreamCollectionId() const;

    /**
     * Prepares check list before candidate pair checks are started.
     * Used with check list corresponding first SDP media line (ICE 5.7 )
     *
     * @since   S60 v3.2
     */
    void InitializeCheckListL();

    /**
     * Prepares check list before candidate pair checks are started.
     * Used for activation after check list for first media line has
     * completed first check for the last media component.
     *
     * @since   S60 v3.2
     * @param   aFoundation     The foundation to match
     */
    void InitializeCheckListL( const TDesC8& aFoundation );

    /**
     * Starts perform periodic connectivity checks.
     *
     * @since   S60 v3.2
     * @param   anInterval      The time interval for pacing checks
     */
    void StartPerformChecksL( 
        const TTimeIntervalMicroSeconds32& anInterval );
    
    /**
     * Restarts check list (due to ICE restart).
     *
     * @since   S60 v3.2
     * @param   anInterval      The time interval for pacing checks     
     */
    void RestartCheckListL( const TTimeIntervalMicroSeconds32& anInterval );
     
    /**
     * Updates check list with peer selected candidate pairs. ICE processing
     * is completed with help of new information.
     * 
     * @since   S60 v3.2
     * @param   aPeerSelectedPairs  Peer selected candidate pairs
     */
    void UpdateCheckListL( 
        RPointerArray<CNATFWCandidatePair>& aPeerSelectedPairs );
    
    /**
     * Updates check list with updated set of remote candidates. 
     * ICE processing is completed with help of new information.
     * 
     * @since   S60 v3.2
     * @param   aRemoteCands        All remote candidates known currently
     */
    void UpdateCheckListL( 
        RPointerArray<CNATFWCandidate>& aRemoteCands );
    
    /**
     * Called when incoming STUN request has come.
     * If aFromAddr == aPeerAddr relay isn't used.
     *
     * @since   S60 v3.2
     * @param   aLocalAddr          To which local address request came
     * @param   aFromAddr           Where request came from as seen by socket
     * @param   aPeerAddr           Real remote address where request came from
     * @param   aPriority           Priority from request
     * @param   aRemoteFavored      Whether candidate pair checked is favored
                                    by remote peer
     */
    void STUNRequestReceivedL( const TInetAddr& aLocalAddr,
        const TInetAddr& aFromAddr, const TInetAddr& aPeerAddr,
        TUint aPriority, TBool aRemoteFavored );
    
    /**
     * Indicates whether relay is used for some selected pair.
     *
     * @since   S60 v3.2
     * @return  ETrue if relay is used
     */
    TBool RelayUsedForSelectedPairL() const;
    
    /**
     * Recomputes pair priorities according to the new role.
     *
     * @since   S60 v3.2
     */
    void RecomputePairPriorities();

// from base class MIceConnCheckListener

    /**
     * From MIceConnCheckListener.
     * Notifies result of a check.
     *
     * @since   S60 v3.2
     * @param   aCompletionCode     The completion code
     * @param   aCheck              The check which was completed
     * @param   aValidatedPair      Candidate pair validated by the check
     */
    void CheckCompletedL( 
        TInt aCompletionCode,
        const CIceConnectivityCheck& aCheck,
        CNATFWCandidatePair* aValidatedPair );

    /**
     * From MIceConnCheckListener.
     * Notifies result of a nomination check.
     *
     * @since   S60 v3.2
     * @param   aCompletionCode     The completion code
     * @param   aCheck              The check
     * @param   aValidatedPair      Candidate pair validated by the check
     */
    void NominationCompletedL( 
        TInt aCompletionCode,
        const CIceConnectivityCheck& aCheck,
        const CNATFWCandidatePair& aValidatedPair );
    
private:

    CIceCheckList(
        MIceChecklistObserver& aClient,
        TUint aStreamCollectionId,
        CIceSessionData& aSessionData,
        CIceConnectionHandler& aConnHandler );

    void ConstructL();

    void GenerateCheckListL( 
        RPointerArray<CIceConnectivityCheck>& aCheckList );
    
    void PairCandidatesL(
        RPointerArray<CIceConnectivityCheck>& aCheckList,
        RPointerArray<CNATFWCandidate>& aLocalCandidates,
        RPointerArray<CNATFWCandidate>& aRemoteCandidates );
    
    TBool CompatibleCandidates( const CNATFWCandidate& aCand1, 
        const CNATFWCandidate& aCand2 ) const;
    
    void PruneChecksL( RPointerArray<CIceConnectivityCheck>& aChecks );
    
    void ReplaceReflexiveCandidatesWithBaseL( 
        RPointerArray<CIceConnectivityCheck>& aChecks );
    
    void OnTimerFiredL();
    
    TUint PriorityForPeerReflCandL( 
        const CNATFWCandidate& aLocalCandidate ) const;
        
    void HandleTriggeredCheckL( const CNATFWCandidatePair& aPair );
    
    void UpdateCheckListStateL();
    
    void RemovePendingChecks( TUint aComponentId );
    
    void GetComponentIdsL( RArray<TUint>& aComponentIds ) const;
    
    TInt FindCheckInState( TInt aStateMask );
    
    TInt FindCheckInState( TInt aStateMask, TUint aComponentId );
    
    TInt FindCheckInState( TInt aStateMask, const TInetAddr& aRemoteAddr );
    
    TInt FindCheck( const CNATFWCandidatePair& aPair );
    
    void SetStateL( TIceCheckListState aState );
    
    void DoLosingPairProcessingL( 
        const RPointerArray<CNATFWCandidatePair>& aSelectedPairs );
    
    void NominateCandidatePairsL();
    
    TBool CheckListFrozen();
    
    void EnqueueCheckL( CIceConnectivityCheck& aCheck,
        CIceConnectivityCheck::TIceCheckType aType, TUint aLocalPriority );
    
    TBool DequeueCheckL();
    
    TUint RetransmissionTimeOut() const;

    CDesC8ArrayFlat* FoundationsForCollectionL( TUint aStreamCollectionId ) const;
    
    TUint LowestComponentId( RArray<TUint>& aComponentIds ) const;
    
    TBool NominationExecuted() const;
    
    void InitializeCheckList( const TDesC8& aFoundation, 
        TInt aExcludedComponentId );
        
private: // data

    /**
     * ICE check list state.
     */
    TIceCheckListState iState;

    /**
     * Stream collection for which this check list is.
     */
    TUint iStreamCollectionId;
    
    /**
     * Timer interval for pacing checks.
     */
    TTimeIntervalMicroSeconds32 iInterval;
    
    /**
     * Client notified about a result of the check.
     * Not own.
     */
    MIceChecklistObserver& iClient;
    
    /**
     * The session data.
     * Not own.
     */
    CIceSessionData& iSessionData;
    
    /**
     * Connection handler.
     * Not own.
     */
    CIceConnectionHandler& iConnHandler;

    /**
     * Ordered list of checks to be executed.
     * Own.
     */
    RPointerArray<CIceConnectivityCheck> iChecks;
    
    /**
     * Check queue for congestion control purposes.
     * Own.
     */
    RArray<TIceCheckQueItem> iCheckQue;
    
    /**
     * Prioritizer for the checks.
     * Own.
     */
    CIceCheckPrioritizer* iCheckPrioritizer;
    
    /**
     * Prioritizer for the local candidates.
     * Own.
     */
    CIceCandidatePrioritizer* iCandPrioritizer;

    /**
     * Timer for connectivity check triggering.
     * Own.
     */
    CPeriodic* iTimer;
    
    /**
     * Valid list.
     * Own.
     */
    CIceValidList* iValidList;

    /**
     * Component identifiers.
     * Own.
     */
    RArray<TUint> iComponentIds;

    /**
     * Remote selected candidate pairs.
     * Own.
     */
    RPointerArray<CNATFWCandidatePair> iSelectedPairs;
    };


#endif // C_CICECHECKLIST_H