/*

* Copyright (c) 2006 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:  Presence Service Connection group member subscription implementation.

*

*/

#include <badesca.h>

#include "groupcontentsubscriptionitem.h"

#include "presenceinfofilterimp.h"

#include "ximpitemparent.h"

#include "ximppanics.h"

#include "ximppsccontext.h"

#include "documentutils.h"

#include "presentitygroupcontenteventimp.h"

#include "presencetypehelpers.h"

#include "ximpobjecthelpers.h"

#include "presentitygroupmemberinfoimp.h"

#include "ximpidentityimp.h"

#include "groupcontenteventobserver.h"

#include "ximptrace.h"

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

// CGroupContentSubscriptionItem::CGroupContentSubscriptionItem()

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

//

CGroupContentSubscriptionItem::CGroupContentSubscriptionItem( MXIMPItemParentBase& aParent )

: CXIMPSubscriptionItemBase( aParent )

    {

    }

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

// CGroupContentSubscriptionItem::ConstructL()

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

//

void CGroupContentSubscriptionItem::ConstructL( const CXIMPIdentityImp& aGroupId )

    {

    BaseConstructL();

    iGroupId = TXIMPObjectCloner< CXIMPIdentityImp >::CloneL( aGroupId );

    // empty lists must always exist

    iCurrentMembers = new ( ELeave) RPrGrpMemInfoImpArray;

    iAdded = new ( ELeave ) RPrGrpMemInfoImpArray;

    iUpdated = new ( ELeave ) RPrGrpMemInfoImpArray;

    iRemoved = new ( ELeave ) RPrGrpMemInfoImpArray;

    }

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

// CGroupContentSubscriptionItem::NewLC()

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

//

CGroupContentSubscriptionItem*

        CGroupContentSubscriptionItem::NewLC( MXIMPItemParentBase& aParent,

                                                     const CXIMPIdentityImp& aGroupId )

    {

    CGroupContentSubscriptionItem* self =

                new( ELeave ) CGroupContentSubscriptionItem( aParent );

    CleanupClosePushL( *self );

    self->ConstructL( aGroupId );

    return self;

    }

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

// CGroupContentSubscriptionItem::~CGroupContentSubscriptionItem()

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

//

CGroupContentSubscriptionItem::~CGroupContentSubscriptionItem()

    {

        MXIMPItemParent* presCache = static_cast<MXIMPItemParent*>(iParent.GetInterface(PRESENCE_ITEM_PARENT));

    presCache->RemoveMe( this );

    if ( iCurrentMembers )

        {

        iCurrentMembers->Close();

        }

    delete iCurrentMembers;

    Clean();

    delete iAdded;

    delete iUpdated;

    delete iRemoved;

    delete iGroupId;

    iEventObservers.Close();

    }

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

// CGroupContentSubscriptionItem::AddOrRenewSubscriberL()

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

//

EXPORT_C void CGroupContentSubscriptionItem::AddOrRenewSubscriberL(

        MXIMPPscContext* aContext )

    {

    TInt index = iContexts.Find( aContext );

    if( index == KErrNotFound )

        {

        iContexts.AppendL( aContext );

        User::LeaveIfError( Open() );

        }

    }

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

// CGroupContentSubscriptionItem::GroupId()

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

//

EXPORT_C const CXIMPIdentityImp& CGroupContentSubscriptionItem::GroupId() const

    {

    return *iGroupId;

    }

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

// CGroupContentSubscriptionItem::Order()

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

//

EXPORT_C TInt CGroupContentSubscriptionItem::Order(

                        const CGroupContentSubscriptionItem& aA,

                        const CGroupContentSubscriptionItem& aB )

    {

    return IdentityOrder( aA.iGroupId, aB );

    }

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

// CPresentityPresenceSubscriptionItem::Order()

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

//

EXPORT_C TInt CGroupContentSubscriptionItem::IdentityOrder(

                        const CXIMPIdentityImp* aA,

                        const CGroupContentSubscriptionItem& aB )

    {

    return aA->Compare( *aB.iGroupId );

    }

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

// From MXIMPSubscriptionItem class.

// CGroupContentSubscriptionItem::SynthesiseSubscriptionEventTo()

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

//

void CGroupContentSubscriptionItem::SynthesiseSubscriptionEventToL(

        MXIMPPscContext* aContext, TBool aForceEvent )

    {

    TRACE_1( _L("CGroupContentSubscriptionItem::SynthesiseSubscriptionEventTo() aForce=%d"), aForceEvent );

    CXIMPDataSubscriptionStateImp* status = StatusLC( aContext );

    if( status->DataState() == MXIMPDataSubscriptionState::EDataAvailable || aForceEvent )

        {

        CPresentityGroupContentEventImp* newEvent =

            CPresentityGroupContentEventImp::NewL( *iGroupId,

                    iAdded,

                    iUpdated,

                    iRemoved,

                    aForceEvent ? iCurrentMembers : NULL,

                    status

                    );

        CleanupStack::Pop(); //status

        CleanupStack::PushL( newEvent );

        MXIMPItemParent* presCache = static_cast<MXIMPItemParent*>(iParent.GetInterface(PRESENCE_ITEM_PARENT));

        presCache->AddEventL( *newEvent, aContext );

        }        

    CleanupStack::PopAndDestroy(); // status || newEvent. Depending on branch.

    }

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

// CGroupContentSubscriptionItem::SynthesiseSubscriptionEventToAllCtxsL()

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

//

void CGroupContentSubscriptionItem::SynthesiseSubscriptionEventToAllCtxsL()

{

TRACE_1( _L("CGroupContentSubscriptionItem::SynthesiseSubscriptionEventToAllCtxsL() iEventObservers.Count()=%d"), iEventObservers.Count() );

TRACE_1( _L("CGroupContentSubscriptionItem::SynthesiseSubscriptionEventToAllCtxsL() iAdded->Count()=%d"), iAdded->Count() );

TRACE_1( _L("CGroupContentSubscriptionItem::SynthesiseSubscriptionEventToAllCtxsL() iUpdated->Count()=%d"), iUpdated->Count() );

TRACE_1( _L("CGroupContentSubscriptionItem::SynthesiseSubscriptionEventToAllCtxsL() iRemoved->Count()=%d"), iRemoved->Count() );

    TInt count = iEventObservers.Count();

    if( count && iAdded->Count() )

    {

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

        {

        TRACE_1( _L("CGroupContentSubscriptionItem::SynthesiseSubscriptionEventToAllCtxsL() observer = iEventObservers[ a ] =%d"), a );

            MGroupContentEventObserver* observer = iEventObservers[ a ];

        TInt error ( KErrNone );

        TRAP( error, observer->HandleSynthesiseL( *iAdded ););

        TRACE_1( _L("CGroupContentSubscriptionItem::SynthesiseSubscriptionEventToAllCtxsL()  TRAPD( error, observer->HandleSynthesiseL =%d"), error );

        }

    }

  TRACE( _L("CGroupContentSubscriptionItem::SynthesiseSubscriptionEventToAllCtxsL - Call to CXIMPSubscriptionItemBase::SynthesiseSubscriptionEventToAllCtxsL Now ") );

    CXIMPSubscriptionItemBase::SynthesiseSubscriptionEventToAllCtxsL();

}

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

// CGroupContentSubscriptionItem::SetNewListL()

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

//

EXPORT_C void CGroupContentSubscriptionItem::SetNewListL(

        RPrGrpMemInfoImpArray* aMemberList )

    {

    TRACE_1( _L("CGroupContentSubscriptionItem::SetNewListL() aMemberList Count=%d"), aMemberList->Count() );

    // we will eventually take ownership to this

    RPrGrpMemInfoImpArray* tmp = aMemberList;

    CleanupStack::PushL( tmp );

    // the list is already sorted. when a copy was made in datacacheimp, the

    // InsertInOrder method was used

    // The below algorithm has complexity of (roughly):

    //   - aMemberList length M

    //   - iCurrentMembers final length N

    //

    //   Final complexity:

    //     M*(    1     // indexed accessor

    //          + logN  // find (ordered)

    //          + logN  // insert in order (find+insert)

    //          + O(1)  // delete

    //          + O(1)  // remove

    //        ) + O(1)  // updating iRemoved and iCurrentMembers

    //     = M(2logN+3) + 2MlogN+3M = O(cMlogM).

    //

    // Should be fast enough. The complexity is not fully accurate because

    // array size grows as we insert into it.

    //

    TLinearOrder<CPresentityGroupMemberInfoImp>

        linearOrder( CPresentityGroupMemberInfoImp::GroupIdLinearOrder );

    for ( TInt i = 0; i < tmp->Count(); i++ )

        {

        // compare against current list

        CPresentityGroupMemberInfoImp* info = (*tmp)[ i ];

        TInt pos = iCurrentMembers->FindInOrder( info, linearOrder );

        if ( pos == KErrNotFound )

            {

            // not found in current list

            // so must be a fresh created list name

            iAdded->InsertInOrderL( info, linearOrder );

            }

        else

            {

            // found in current list, so it must be an updated list name

            iUpdated->InsertInOrderL( info, linearOrder );

            delete (*iCurrentMembers)[ pos ];

            iCurrentMembers->Remove( pos );

            // we must remove the found ones from iCurrentMembers,

            // otherwise we will not know what was left. and finding out

            // the removed items will be difficult.

            }

        }

    // what's left in iCurrentMembers contains the deleted ones.

    delete iRemoved;

    iRemoved = iCurrentMembers;

    // the given list becomes the new list

    iCurrentMembers = tmp;

    CleanupStack::Pop( tmp );

    iSubscriptionState->SetDataStateL( MXIMPDataSubscriptionState::EDataAvailable );

    InformObserversL();

    }

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

// CGroupContentSubscriptionItem::SetAddedListL()

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

//

EXPORT_C void CGroupContentSubscriptionItem::SetAddedListL(

        RPrGrpMemInfoImpArray* aMemberList )

    {

    TRACE_1( _L("CGroupContentSubscriptionItem::SetAddedListL() aMemberList Count=%d"), aMemberList->Count() );

    // we took ownership to the given list

    RPrGrpMemInfoImpArray* tmp = aMemberList;

    CleanupDeletePushL( tmp );

    // see also SetNewListL.

    // the list is already sorted. when a copy was made in datacacheimp, the

    // InsertInOrder method was used

    TLinearOrder<CPresentityGroupMemberInfoImp>

        linearOrder( CPresentityGroupMemberInfoImp::GroupIdLinearOrder );

    // update the list of created and updated groups

    for ( TInt i = 0; i < tmp->Count(); i++ )

        {

        // compare against current list

        CPresentityGroupMemberInfoImp* info = (*tmp)[ i ];

        TInt pos = iCurrentMembers->FindInOrder( info, linearOrder );

        if ( pos == KErrNotFound )

            {

            // not found in current list

            // so must be a fresh created list name.

            // this cannot come when the HandleDisplayNameUpdatedListL method

            // is called.

            iCurrentMembers->InsertInOrderL( info, linearOrder );

            ( *tmp )[ i ] = NULL;

            iAdded->InsertInOrderL( info, linearOrder );

            }

        else

            {

            // This can be checked if really had changed if needed. Now

            // we trust server that changes are reasonable.

            // change the display name of the updated group in the current list

            (*iCurrentMembers)[ pos ]->SetGroupMemberDisplayNameL( info->GroupMemberDisplayName() );

            // found in current list, so it must be an updated list name

            iUpdated->InsertInOrderL( (*iCurrentMembers)[ pos ], linearOrder );

            }

        }

    // current list may get updated display name to the existing elements,

    // otherwise the list is unchanged. list of deleted groups stays empty.

    // updated and created lists were updated. the input parameter list can be

    // deleted

    CleanupStack::PopAndDestroy( tmp );

    iSubscriptionState->SetDataStateL( MXIMPDataSubscriptionState::EDataAvailable );

    InformObserversL();

    }

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

// CGroupContentSubscriptionItem::SetRemovedListL()

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

//

EXPORT_C void CGroupContentSubscriptionItem::SetRemovedListL(

        RPrGrpMemInfoImpArray* aMemberList )

    {

    TRACE_1( _L("CGroupContentSubscriptionItem::SetRemovedListL() aMemberList Count=%d"), aMemberList->Count() );

    // we will eventually take ownership to this

    RPrGrpMemInfoImpArray* tmp = aMemberList;

    CleanupStack::PushL( tmp );

    // see also SetNewListL.

    // the list is already sorted. when a copy was made in datacacheimp, the

    // InsertInOrder method was used

    TLinearOrder<CPresentityGroupMemberInfoImp>

        linearOrder( CPresentityGroupMemberInfoImp::GroupIdLinearOrder );

    // remove the deleted ones from the current list

    for ( TInt i = 0; i < tmp->Count(); i++ )

        {

        // compare against current list

        CPresentityGroupMemberInfoImp* info = (*tmp)[ i ];

        TInt pos = iCurrentMembers->FindInOrder( info, linearOrder );

        // found in current list, so it must be a deleted list name

        if ( pos != KErrNotFound )

            {

            // remove from current list

            delete (*iCurrentMembers)[ pos ];

            iCurrentMembers->Remove( pos );

            }

        }

    // the given list becomes the new list of

    // removed ones

    delete iRemoved;

    iRemoved = tmp;

    CleanupStack::Pop( tmp );

    iSubscriptionState->SetDataStateL( MXIMPDataSubscriptionState::EDataAvailable );

    InformObserversL();

    }

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

// CGroupContentSubscriptionItem::Clean()

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

//

EXPORT_C void CGroupContentSubscriptionItem::Clean()

    {

    TRACE( _L("CGroupContentSubscriptionItem::Clean") );

    // empty the lists.

    // the lists must stay valid for use

    // iAdded and iUpdated are collection from currentlist. Do not delete items.

    // iRemoved is only place for items. Delete those.

    iAdded->Reset();

    iUpdated->Reset();

    iRemoved->Close();

    }

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

// CGroupContentSubscriptionItem::GroupMemberExistsL()

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

//

EXPORT_C TBool CGroupContentSubscriptionItem::GroupMemberExistsL(

                            CPresentityGroupMemberInfoImp& aMemberInfo ) const

    {

    TBool found( EFalse );

    CPresentityGroupMemberInfoImp* memberInfo =

        TXIMPObjectCloner< CPresentityGroupMemberInfoImp >::CloneL( aMemberInfo );

    CleanupStack::PushL( memberInfo );

    TLinearOrder<CPresentityGroupMemberInfoImp>

        linearOrder( CPresentityGroupMemberInfoImp::GroupIdLinearOrder );

    TInt pos = iCurrentMembers->FindInOrder( memberInfo, linearOrder );

    if ( pos != KErrNotFound )

        {

        found = ETrue;

        }

    CleanupStack::PopAndDestroy( memberInfo );

    TRACE_1( _L("CGroupContentSubscriptionItem::GroupMemberExistsL() returns=%d"), found );

    return found;

    }

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

// CGroupContentSubscriptionItem::IsGroupMemberUpdatedL()

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

//

EXPORT_C TBool CGroupContentSubscriptionItem::IsGroupMemberUpdatedL(

                            CPresentityGroupMemberInfoImp& aMemberInfo ) const

    {

    TBool updated( EFalse );

    if ( !GroupMemberExistsL( aMemberInfo ) )

        {

        return updated;

        }

    CPresentityGroupMemberInfoImp* memberInfo =

        TXIMPObjectCloner< CPresentityGroupMemberInfoImp >::CloneL( aMemberInfo );

    CleanupStack::PushL( memberInfo );

    TLinearOrder<CPresentityGroupMemberInfoImp>

        linearOrder( CPresentityGroupMemberInfoImp::GroupIdLinearOrder );

    TInt pos = iCurrentMembers->FindInOrder( memberInfo, linearOrder );

    // it exists, otherwise we would've returned after GroupMemberExistsL call

    CPresentityGroupMemberInfoImp* foundMember = (*iCurrentMembers)[ pos ];

    // Compare identity and displayname

    if ( memberInfo->GroupMemberId().Identity().Compare(

                            foundMember->GroupMemberId().Identity() ) != 0

                            ||

         memberInfo->GroupMemberDisplayName().Compare(

                            foundMember->GroupMemberDisplayName() ) != 0 )

        {

        updated = ETrue;

        }

    CleanupStack::PopAndDestroy( memberInfo );

    TRACE_1( _L("CGroupContentSubscriptionItem::IsGroupMemberUpdatedL() returns=%d"), updated );

    return updated;

    }

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

// CGroupContentSubscriptionItem::MemberCount()

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

//

TInt CGroupContentSubscriptionItem::MemberCount() const

    {

    TRACE_1( _L("CGroupContentSubscriptionItem::MemberCount() returns=%d"), iCurrentMembers->Count() );

    return iCurrentMembers->Count();

    }

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

// CGroupContentSubscriptionItem::MemberAt()

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

//

CPresentityGroupMemberInfoImp& CGroupContentSubscriptionItem::MemberAt( TInt aIndex )

    {

    return *( *iCurrentMembers )[ aIndex ];

    }

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

// CGroupContentSubscriptionItem::RegisterEventObserverL()

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

//

void CGroupContentSubscriptionItem::RegisterEventObserverL(

                        MGroupContentEventObserver* aEventObserver )

    {

    TInt indexOfObserver = iEventObservers.Find( aEventObserver );

    if( indexOfObserver == KErrNotFound )

        {

        iEventObservers.AppendL( aEventObserver );

        User::LeaveIfError( Open() );

        }

    }

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

// CGroupContentSubscriptionItem::UnregisterEventObserver()

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

//

void CGroupContentSubscriptionItem::UnregisterEventObserver(

                        MGroupContentEventObserver* aEventObserver )

    {

    TInt indexOfObserver = iEventObservers.Find( aEventObserver );

    if( indexOfObserver != KErrNotFound )

        {

        iEventObservers.Remove( indexOfObserver );

        Close();

        }

    }

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

// CGroupContentSubscriptionItem::CleanExpired()

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

//

void CGroupContentSubscriptionItem::CleanExpired()

    {

    }

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

// CGroupContentSubscriptionItem::InformObserversL()