/*
* Copyright (c) 2005 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 "mcesrvstreamiterator.h"
#include "mcecommediastream.h"
#include "mcecommediasource.h"
#include "mcecommediasink.h"
#include "mcesrvendpoint.h"
#include "mceevents.h"
#include "mcecomendpointproxy.h"
#include "mcecomcodec.h"


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


// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::TMceSrvStreamIterator
// -----------------------------------------------------------------------------
//
TMceSrvStreamIterator::TMceSrvStreamIterator( const RPointerArray<CMceSrvStream>& aStreams )
    : iStreams( aStreams ),
      iDirection( EZero ),
      iStream( NULL ),
      iEndpoint( NULL ),
      iCodec( NULL ),
      iCurrentIndex( 0 ),
      iUseProxyMatch( EFalse )
    {
    }
    

// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::TMceSrvStreamIterator
// -----------------------------------------------------------------------------
//
TMceSrvStreamIterator::TMceSrvStreamIterator( const RPointerArray<CMceSrvStream>& aStreams,
                                              TDirection aDirection )
    : iStreams( aStreams ),
      iDirection( aDirection ),
      iStream( NULL ),
      iEndpoint( NULL ),
      iCodec( NULL ),
      iCurrentIndex( 0 ),
      iUseProxyMatch( EFalse )
    {
    }
    

// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::TMceSrvStreamIterator
// -----------------------------------------------------------------------------
//
TMceSrvStreamIterator::TMceSrvStreamIterator( const RPointerArray<CMceSrvStream>& aStreams,
                                              const CMceComMediaStream& aStream )
    : iStreams( aStreams ),
      iDirection( EZero ),
      iStream( &aStream ),
      iEndpoint( NULL ),
      iCodec( NULL ),
      iCurrentIndex( 0 ),
      iUseProxyMatch( EFalse )
    {
    }

// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::TMceSrvStreamIterator
// -----------------------------------------------------------------------------
//
TMceSrvStreamIterator::TMceSrvStreamIterator( const RPointerArray<CMceSrvStream>& aStreams,
                                              const CMceComEndpoint& aEndpoint,
                                              TBool aUseProxyMatch,
                                              TDirection aDirection,
                                              const CMceComCodec* aCodec )
    : iStreams( aStreams ),
      iDirection( aDirection ),
      iStream( NULL ),
      iEndpoint( &aEndpoint ),
      iCodec( aCodec ),
      iCurrentIndex( 0 ),
      iUseProxyMatch( aUseProxyMatch )
    {
    }

// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::TMceSrvStreamIterator
// -----------------------------------------------------------------------------
//
TMceSrvStreamIterator::TMceSrvStreamIterator( const RPointerArray<CMceSrvStream>& aStreams,
                                              const CMceComCodec& aCodec )
    : iStreams( aStreams ),
      iDirection( EZero ),
      iStream( NULL ),
      iEndpoint( NULL ),
      iCodec( &aCodec ),
      iCurrentIndex( 0 ),
      iUseProxyMatch( EFalse )
    {
    }



// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::Next
// -----------------------------------------------------------------------------
//
TBool TMceSrvStreamIterator::Next( CMceSrvStream*& aCandidate,
                                   TMceMccComEvent& aRecipient,
                                   TStreamStateMatchType aMatchType )

    {
    CMceSrvStream* next = NULL;
    TBool eof = EFalse;
    while ( !eof && Next( next, aMatchType ) )
        {
        eof = next->Consumes( aRecipient );
        next = eof ? next : NULL;
        }
        
    aCandidate = next;
    return aCandidate ? ETrue : EFalse;
    
    }

// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::Next
// -----------------------------------------------------------------------------
//
TBool TMceSrvStreamIterator::Next( CMceSrvStream*& aCandidate,
                                   CMceSrvStream& aClone,
                                   TStreamStateMatchType aMatchType )
    {
    CMceSrvStream* next = NULL;
    TBool eof = EFalse;
    while ( !eof && Next( next, aMatchType ) )
        {
        eof = next->IsEqual( aClone );
        next = eof ? next : NULL;
        }
        
    aCandidate = next;
    return aCandidate ? ETrue : EFalse;
    
    }
    

// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::NextIntersect
// -----------------------------------------------------------------------------
//
TBool TMceSrvStreamIterator::NextIntersect( CMceSrvStream*& aCandidate,
                                            TMceSrvStreamIterator& aSet, 
                                            CMceSrvStream*& aSetIntersect )
    {

    CMceSrvStream* intersect = NULL;
    aSetIntersect = NULL;
    
    while( !aSetIntersect && Next( intersect ) )
        {
        aSet.Reset();
        aSet.Next( aSetIntersect, *intersect );
        }

    intersect = aSetIntersect ? intersect : NULL;
    
    aCandidate = intersect;
    return aCandidate ? ETrue : EFalse;
    
    }
    
// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::NextComplement
// -----------------------------------------------------------------------------
//
TBool TMceSrvStreamIterator::NextComplement( CMceSrvStream*& aCandidate,
                                             TMceSrvStreamIterator& aSet )
    {
    TBool found = EFalse;
    
    CMceSrvStream* complement = NULL;
    
    while( !found && Next( complement ) )
        {
        aSet.Reset();
        CMceSrvStream* c = NULL;
        found = !aSet.Next( c, *complement );
        }
    
    aCandidate = complement;
    return aCandidate ? ETrue : EFalse;
    
    }
    

// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::Next
// -----------------------------------------------------------------------------
//
TBool TMceSrvStreamIterator::Next( 
                CMceSrvStream*& aCandidate,
                CMceSrvStream::TState aState, 
                TMceSrvStreamIterator::TStreamStateMatchType aMatchType )
    {    
    CMceSrvStream* next = NULL;
    TBool eof = EFalse;
    
    while ( !eof && Next( next ) )
        {
        TBool condition = ETrue;
        TBool negation = ETrue;
        switch( aMatchType )
            {
             case ExactMatch:
                {
                condition = next->State() == aState;
                negation = EFalse;
                break;
                }
            case ExactReverseMatch:
                {
                condition = next->State() == aState;
                negation = ETrue;
                break;
                }
            case GreaterOrEqualMatch:
                {
                condition = next->State() >= aState;
                negation = EFalse;
                break;
                }
            case GreaterOrEqualReverseMatch:
                {
                condition = next->State() >= aState;
                negation = ETrue;
                break;
                }
            }
        eof = ( ( negation && !condition ) ||
                ( !negation && condition ) );
        next = eof ? next : NULL;
        }

    aCandidate = next;
    return aCandidate ? ETrue : EFalse;
    
    }


// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::Current
// -----------------------------------------------------------------------------
//
TInt TMceSrvStreamIterator::Current()
    {
    TInt current = KErrNotFound;
    
    if ( iStreams.Count() > 0 )
        {
        current = iCurrentIndex-1;
        current = current < 0 ? 0 : current;
        }
    return current;
    
    }

// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::Remove
// -----------------------------------------------------------------------------
//
TInt TMceSrvStreamIterator::Remove( RPointerArray<CMceSrvStream>& aStreams )
    {
    TInt current = Current();
    
    if ( current != KErrNotFound )
        {
        aStreams.Remove( current );
        iCurrentIndex = current;
        }
    
    return current;
    
    }


// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::IsEof
// -----------------------------------------------------------------------------
//
TBool TMceSrvStreamIterator::IsEof()
    {
    return iStreams.Count() == 0 || iCurrentIndex >= iStreams.Count();
    }

// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::Direction
// -----------------------------------------------------------------------------
//
TMceSrvStreamIterator::TDirection TMceSrvStreamIterator::Direction()
    {
    return iDirection;
    }

// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::Next
// -----------------------------------------------------------------------------
//
TBool TMceSrvStreamIterator::Next( 
                    CMceSrvStream*& aCandidate,
                    TMceSrvStreamIterator::TStreamStateMatchType aMatchType )

    {
    CMceSrvStream* next = NULL;
    TBool negation = aMatchType == ExactMatch ? EFalse : ETrue;
    
    while( !next && !IsEof() )
        {
        CMceSrvStream* srvStream = iStreams[ iCurrentIndex ];
        TBool condition = EFalse;
        
        if ( iEndpoint )
            {
            condition = srvStream->EndpointMatch( *iEndpoint, iUseProxyMatch );
            if ( condition && iCodec )
                {
                condition = srvStream->Codec().Decodes( 
                                iCodec->iSdpName, iCodec->FmtpAttr() );
                }
                 
            if ( condition && ( iDirection != EZero || iCodec ) )
                {
                condition = DoDirectionMatch( *srvStream );
                }   
            }
        else if ( iDirection != EZero )
            {
            condition = DoDirectionMatch( *srvStream );
            }
        else if ( iStream )
            {
            condition = srvStream->Data().Id() == iStream->Id();
            }
        else if ( iCodec )
            {
            condition = &srvStream->Codec() == iCodec;
            }
        else
            {
            condition = ETrue;
            }
        next = ( ( negation && !condition ) ||
               ( !negation && condition ) ) ? srvStream : NULL;
               
        iCurrentIndex++;                            
        }
    
    aCandidate = next;
    return aCandidate ? ETrue : EFalse;
    
    }
    


// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::Reset
// -----------------------------------------------------------------------------
//
void TMceSrvStreamIterator::Reset()
    {
    iCurrentIndex = 0;
    }

// -----------------------------------------------------------------------------
// TMceSrvStreamIterator::DoDirectionMatch
// -----------------------------------------------------------------------------
//    
TBool TMceSrvStreamIterator::DoDirectionMatch( CMceSrvStream& aSrvStream )
    {
    TBool condition( ETrue );
    CMceComMediaStream::TStreamType type = aSrvStream.Data().iStreamType;
    switch( iDirection )
        {
        case ELocal:
            {
            condition = type == CMceComMediaStream::ELocalStream;
            break;
            }
        case ESendOrReceive:
            {
            condition = type != CMceComMediaStream::ELocalStream;
            break;
            }
        case ESend:
            {
            condition = ( type == CMceComMediaStream::ESendOnlyStream ||
                          type == CMceComMediaStream::ESendStream );
            break;
            }
        case EReceive:
            {
            condition = ( type == CMceComMediaStream::EReceiveOnlyStream ||
                          type == CMceComMediaStream::EReceiveStream );
            break;
            }
        case EReceiveOrLocal:
            {
            condition = ( type == CMceComMediaStream::EReceiveOnlyStream ||
                          type == CMceComMediaStream::EReceiveStream ||
                          type == CMceComMediaStream::ELocalStream );
            break;
            }
        case ESendOrLocal:
            {
            condition = ( type == CMceComMediaStream::ESendOnlyStream ||
                          type == CMceComMediaStream::ESendStream || 
                          type == CMceComMediaStream::ELocalStream );
            break;
            }
        default://EAny
            {
            condition = ETrue;
            break;
            }
        }
    return condition;
    }