/*

* 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 list subscription implementation.

*

*/

#include "presentitypresencesubscriptionitem.h"

#include "presenceinfofilterimp.h"

#include "ximpitemparent.h"

#include "ximppanics.h"

#include "ximppsccontext.h"

#include "documentutils.h"

#include "presentitypresenceeventimp.h"

#include "ximpdatasubscriptionstateimp.h"

#include "ximpidentityimp.h"

#include "ximpobjecthelpers.h"

#include <presencecachewriter.h>

#include <presencebuddyinfo.h>

#include "ximptrace.h"

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

// CPresentityPresenceSubscriptionItem::CPresentityPresenceSubscriptionItem()

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

//

CPresentityPresenceSubscriptionItem::CPresentityPresenceSubscriptionItem( MXIMPItemParentBase& aParent )

: CXIMPSubscriptionItemBase( aParent )

    {

    }

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

// CPresentityPresenceSubscriptionItem::ConstructL()

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

//

void CPresentityPresenceSubscriptionItem::ConstructL( const CXIMPIdentityImp& aIdentity )

    {

    BaseConstructL();

    iIdentity = TXIMPObjectCloner< CXIMPIdentityImp >::CloneL( aIdentity );

    }

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

// CPresentityPresenceSubscriptionItem::NewLC()

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

//

CPresentityPresenceSubscriptionItem*

    CPresentityPresenceSubscriptionItem::NewLC( MXIMPItemParentBase& aParent, const CXIMPIdentityImp& aIdentity )

    {

    CPresentityPresenceSubscriptionItem* self =

        new( ELeave ) CPresentityPresenceSubscriptionItem( aParent );

    CleanupClosePushL( *self );

    self->ConstructL( aIdentity );

    return self;

    }

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

// CPresentityPresenceSubscriptionItem::~CPresentityPresenceSubscriptionItem()

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

//

CPresentityPresenceSubscriptionItem::~CPresentityPresenceSubscriptionItem()

    {

    // Remove it also from the external cache

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

    if(presCache)

        {

            MPresenceCacheWriter* extCache = presCache->ExternalCache();

            if(extCache && iIdentity)

                TRAP_IGNORE( extCache->DeletePresenceL( *iIdentity ) );

            presCache->RemoveMe( this );

        }

    delete iIdentity;

    delete iPresenceInfo;

    delete iPif;

    }

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

// CPresentityPresenceSubscriptionItem::SubscriptionPif()

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

//

EXPORT_C CPresenceInfoFilterImp&

            CPresentityPresenceSubscriptionItem::SubscriptionPif()

    {

    TRACE(_L("CPresentityPresenceSubscriptionItem::SubscriptionPif" ) );

    // assert removed

    return *iPif;

    }

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

// CPresentityPresenceSubscriptionItem::SetSubscriptionPif()

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

//

EXPORT_C void CPresentityPresenceSubscriptionItem::SetSubscriptionPif(

                                                CPresenceInfoFilterImp* aPif )

    {

    TRACE(_L("CPresentityPresenceSubscriptionItem::SetSubscriptionPif" ) );

    if ( !aPif )

        {

        TRACE(_L("CPresentityPresenceSubscriptionItem::SetSubscriptionPif aPif NULL" ) );

        }

    delete iPif;

    iPif = aPif;

    }

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

// CPresentityPresenceSubscriptionItem::CollectSubscriptionPifWithoutCtxL()

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

//

EXPORT_C CPresenceInfoFilterImp*

    CPresentityPresenceSubscriptionItem::CollectSubscriptionPifWithoutCtxL(

                                                        MXIMPPscContext* aContext )

    {

    TRACE(_L("CPresentityPresenceSubscriptionItem::CollectSubscriptionPifWithoutCtxL" ) );

    RPointerArray< CPresenceInfoFilterImp > arrayOfPifs;

    CleanupClosePushL( arrayOfPifs );

    TInt count = iContexts.Count();

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

        {

        if( iContexts[ a ] != aContext )

            {

            CPresenceInfoFilterImp* filter = iContexts[ a ]->PresenceInfoFilter( 

                        MXIMPPscContext::EPresentityPresenceFilter, iIdentity );

            if ( filter )

                {

                arrayOfPifs.AppendL( filter );

                }

            }

        }

    CPresenceInfoFilterImp* pifWithoutCtx = DocumentUtils::InfoFilterUnionL( arrayOfPifs );

    CleanupStack::PopAndDestroy(); // arrayOfPifs

    return pifWithoutCtx;

    }

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

// CPresentityPresenceSubscriptionItem::SetPresenceInfoL()

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

//

EXPORT_C void CPresentityPresenceSubscriptionItem::SetPresenceInfoL(

                                            CPresenceInfoImp* aPresenceInfo )

    {

    TRACE(_L("CPresentityPresenceSubscriptionItem::SetPresenceInfoL" ) );

    delete iPresenceInfo;

    iPresenceInfo = aPresenceInfo;

    iSubscriptionState->SetDataStateL( MXIMPDataSubscriptionState::EDataAvailable );

    // Now let's update the external presence cache

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

    MPresenceCacheWriter* extCache = presCache->ExternalCache();

    MPresenceBuddyInfo* buddyPresence = extCache->NewBuddyPresenceInfoLC();

    // we need to clonce the parameters since the ownership is transfered

    CXIMPIdentityImp* identity = TXIMPObjectCloner<CXIMPIdentityImp>::CloneL(*iIdentity);

    buddyPresence->SetBuddyId( identity );

    CPresenceInfoImp* presenceInfo = TXIMPObjectCloner<CPresenceInfoImp>::CloneL(*iPresenceInfo);

    buddyPresence->SetPresenceInfo( presenceInfo );

    // No harm to do this, because the internal cache is still working

    // we just lose the external update

    TRAP_IGNORE( extCache->WritePresenceL( buddyPresence ) );

    CleanupStack::PopAndDestroy( 1 ); // buddyPresence

    }

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

// CPresentityPresenceSubscriptionItem::Order()

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

//

EXPORT_C TInt CPresentityPresenceSubscriptionItem::Order(

                        const CPresentityPresenceSubscriptionItem& aA,

                        const CPresentityPresenceSubscriptionItem& aB )

    {

    return IdentityOrder( aA.iIdentity, aB );

    }

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

// CPresentityPresenceSubscriptionItem::Order()

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

//

EXPORT_C TInt CPresentityPresenceSubscriptionItem::IdentityOrder(

                        const CXIMPIdentityImp* aA,

                        const CPresentityPresenceSubscriptionItem& aB )

    {

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

    }

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

// CPresentityPresenceSubscriptionItem::Identity()

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

//

EXPORT_C const MXIMPIdentity& CPresentityPresenceSubscriptionItem::Identity() const

    {

    return *iIdentity;

    }

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

// CPresentityPresenceSubscriptionItem::GroupIdentity()

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

//

EXPORT_C const MXIMPIdentity* CPresentityPresenceSubscriptionItem::GroupIdentity() const

    {

    return iGroupIdentity;

    }

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

// CPresentityPresenceSubscriptionItem::SetIdentity()

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

//

EXPORT_C void CPresentityPresenceSubscriptionItem::SetIdentity(

                                            CXIMPIdentityImp* aIdentity )

    {

    delete iIdentity;

    iIdentity = aIdentity;

    }

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

// CPresentityPresenceSubscriptionItem::SetGroupIdentity()

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

//

EXPORT_C void CPresentityPresenceSubscriptionItem::SetGroupIdentity(

                                            CXIMPIdentityImp* aGroup )

    {

    delete iGroupIdentity;

    iGroupIdentity = aGroup;

    }

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

// From class MXIMPSubscriptionItem.

// CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventTo()

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

//

void CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL(

                                                    MXIMPPscContext* aContext,

                                                    TBool aForceEvent )

    {

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

    CXIMPDataSubscriptionStateImp* status = StatusLC( aContext ); // << status

    CPresentityPresenceEventImp* newEvent = NULL;

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

        {

        TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL 2" ) );

        __ASSERT_ALWAYS( iPresenceInfo, User::Panic( NXIMPPrivPanic::KCategory,

                                            NXIMPPrivPanic::EPresentityPresencePresenceInfoDoesNotExist ) );

        TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL 3" ) );

		// ERIK TODO: Logic is the following:

		// 1 - Find all the groups where the iIdentity belongs to

		// 2 - Collect the filters from those groups

		// 3 - collect the filter from the individual subscription item also own

		// 4 - make a union of the filters

        CPresenceInfoFilterImp* groupPif = NULL;

        if ( iGroupIdentity ) 

            { 

            groupPif = aContext->PresenceInfoFilter( MXIMPPscContext::EPresentityGroupMemberPresenceFilter, iGroupIdentity );

            if ( !iPif )

                {

                TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL ownPif found" ) );

                iPif = TXIMPObjectCloner< CPresenceInfoFilterImp >::CloneLC( *groupPif );

                CleanupStack::Pop();

                }

            }

        TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL 4_0" ) );

        CPresenceInfoFilterImp* ownPif = aContext->PresenceInfoFilter( MXIMPPscContext::EOwnPresenceFilter, iIdentity );

        TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL 4_1" ) );

        CPresenceInfoFilterImp* presentityPif = aContext->PresenceInfoFilter( MXIMPPscContext::EPresentityPresenceFilter, iIdentity );

        TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL 4_2" ) );

    	RPointerArray< CPresenceInfoFilterImp > arrayOfPifs;    // << arrayOfPifs

    	CleanupClosePushL( arrayOfPifs );

        if ( groupPif )

            {

            TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL groupPif found" ) );

            arrayOfPifs.AppendL( groupPif );

            if ( !iPif )

                {

                TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL iPif created" ) );

                SetSubscriptionPif( groupPif );

                //iPif = TXIMPObjectCloner< CPresenceInfoFilterImp >::CloneLC( groupPif );

                //CleanupStack::Pop();

                }

            }

        if ( ownPif )

            {

            TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL ownPif found" ) );

            arrayOfPifs.AppendL( ownPif );

            }

        if ( presentityPif )

            {

            TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL presentityPif found" ) );

            arrayOfPifs.AppendL( presentityPif );

            }

        TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL 4_3" ) );

		CPresenceInfoFilterImp* unionPif = NULL;

    	unionPif = DocumentUtils::InfoFilterUnionL( arrayOfPifs );    

    	if ( unionPif ) 

    	    {

    	    TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL unionPif found" ) );

    	    }

    	CleanupStack::PopAndDestroy(); // >>> arrayOfPifs

    	CleanupStack::PushL( unionPif );    // << unionPif

        TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL 5" ) );

        CPresenceInfoImp* filteredPresenceInfo = 

                DocumentUtils::CollectFilteredPresenceInfoLC(

                    *unionPif, 

                    *iPresenceInfo );   // << filteredPresenceInfo

        CleanupStack::Pop( filteredPresenceInfo ); // >> filteredPresenceInfo

        CleanupStack::PopAndDestroy( unionPif );    // >>> unionPif

        CleanupStack::PushL( filteredPresenceInfo );    // << filteredPresenceInfo

        TRACE(_L("CPresentityPresenceSubscriptionItem::SynthesiseSubscriptionEventToL 6" ) );

        newEvent = CPresentityPresenceEventImp::NewL( status ); // CSI: 35 # Event is put to cleanupstack in next branch.

        newEvent->SetPresenceInfo( filteredPresenceInfo );

        CleanupStack::Pop( filteredPresenceInfo ); // >> filteredPresenceInfo

        CleanupStack::Pop( status );    // >> status

        newEvent->SetIdentityL( *iIdentity );

        }

    else if( aForceEvent )

        {

        newEvent = CPresentityPresenceEventImp::NewL( status ); // CSI: 35 # Event is put to cleanupstack in next branch.

        CleanupStack::Pop( status );

        newEvent->SetIdentityL( *iIdentity );

        }

    if( newEvent )

        {

        CleanupStack::PushL( newEvent );

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

        presCache->AddEventL( *newEvent, aContext );

        }

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

    }

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

// CPresentityPresenceSubscriptionItem::CleanExpired()

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

//

void CPresentityPresenceSubscriptionItem::CleanExpired()

    {

    }

// End of file