/*
* 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 <badesca.h>

#include "grouplistsubscriptionitem.h"
#include "presenceinfofilterimp.h"
#include "ximpitemparent.h"
#include "ximppanics.h"
#include "ximppsccontext.h"
#include "documentutils.h"
#include "presentitygrouplisteventimp.h"
#include "presencetypehelpers.h"
#include "presentitygroupinfoimp.h"
//#include "ximpapieventbase.h"

#include "ximptrace.h"
// ---------------------------------------------------------------------------
// CGroupListSubscriptionItem::CGroupListSubscriptionItem()
// ---------------------------------------------------------------------------
//
CGroupListSubscriptionItem::CGroupListSubscriptionItem( MXIMPItemParentBase& aParent )
: CXIMPSubscriptionItemBase( aParent )
    {
    }


// ---------------------------------------------------------------------------
// CGroupListSubscriptionItem::ConstructL()
// ---------------------------------------------------------------------------
//
void CGroupListSubscriptionItem::ConstructL()
    {
    BaseConstructL();
    // empty lists must always exist
    iCurrentList = new ( ELeave) RPrGrpInfoImpArray;

    iCreated = new ( ELeave ) RPrGrpInfoImpArray;
    iUpdated = new ( ELeave ) RPrGrpInfoImpArray;
    iDeleted = new ( ELeave ) RPrGrpInfoImpArray;
    }


// ---------------------------------------------------------------------------
// CGroupListSubscriptionItem::NewL()
// ---------------------------------------------------------------------------
//
CGroupListSubscriptionItem* CGroupListSubscriptionItem::NewLC( MXIMPItemParentBase& aParent )
    {
    CGroupListSubscriptionItem* self = new( ELeave ) CGroupListSubscriptionItem( aParent );
    CleanupClosePushL( *self );
    self->ConstructL();
    return self;
    }


// ---------------------------------------------------------------------------
// CGroupListSubscriptionItem::~CGroupListSubscriptionItem()
// ---------------------------------------------------------------------------
//
CGroupListSubscriptionItem::~CGroupListSubscriptionItem()
    {
        MXIMPItemParent* presCache = static_cast<MXIMPItemParent*>(iParent.GetInterface(PRESENCE_ITEM_PARENT));
    presCache->RemoveMe( this );

    if( iCurrentList )
        {
        iCurrentList->Close();
        }
    delete iCurrentList;

    Clean();
    // just in case
    delete iCreated;
    delete iDeleted;
    delete iUpdated;
    }

// ---------------------------------------------------------------------------
// CGroupListSubscriptionItem::SynthesiseSubscriptionEventTo()
// ---------------------------------------------------------------------------
//
void CGroupListSubscriptionItem::SynthesiseSubscriptionEventToL(
        MXIMPPscContext* aContext, TBool aForceEvent )
    {
    TRACE_1( _L("CGroupListSubscriptionItem::SynthesiseSubscriptionEventTo() aForce=%d"), aForceEvent );
    CXIMPDataSubscriptionStateImp* status = StatusLC( aContext );

    if( status->DataState() == MXIMPDataSubscriptionState::EDataAvailable || aForceEvent )
        {
        CPresentityGroupListEventImp* newEvent = CPresentityGroupListEventImp::NewL(
                iCreated,
                iUpdated,
                iDeleted,
                aForceEvent ? iCurrentList : 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.
    }


// ---------------------------------------------------------------------------
// CGroupListSubscriptionItem::SetNewListL
// ---------------------------------------------------------------------------
//
EXPORT_C void CGroupListSubscriptionItem::SetNewListL(
        RPrGrpInfoImpArray* aGroupList )
    {
    TRACE_1( _L("CGroupListSubscriptionItem::SetNewListL() aGroupList Count=%d"), aGroupList->Count() );
    // we will eventually take ownership to this
    RPrGrpInfoImpArray* tmp = aGroupList;
    CleanupDeletePushL( 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):
    //   - aGroupList length M
    //   - iCurrentList 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 iDeleted and iCurrentList
    //     = 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<CPresentityGroupInfoImp>
        linearOrder( CPresentityGroupInfoImp::GroupIdLinearOrder );

    for ( TInt i = 0; i < tmp->Count(); i++ )
        {
        // compare against current list
        CPresentityGroupInfoImp* info = (*tmp)[ i ];
        TInt pos = iCurrentList->FindInOrder( info, linearOrder );

        if ( pos == KErrNotFound )
            {
            // not found in current list
            // so must be a fresh created list name
            iCreated->InsertInOrderL( info, linearOrder );
            }
        else
            {
            // found in current list, so it must be an updated list name
            iUpdated->InsertInOrderL( info, linearOrder );

            delete (*iCurrentList)[ pos ];
            iCurrentList->Remove( pos );

            // we must remove the found ones from iCurrentList,
            // otherwise we will not know what was left. and finding out
            // the deleted items will be difficult.
            }
        }

    // what's left in iCurrentList contains the deleted ones.
    delete iDeleted;
    iDeleted = iCurrentList;

    // the given list becomes the new list
    iCurrentList = tmp;
    CleanupStack::Pop( tmp );
    iSubscriptionState->SetDataStateL( MXIMPDataSubscriptionState::EDataAvailable );
    }

// ---------------------------------------------------------------------------
// CGroupListSubscriptionItem::SetCreatedListL
// ---------------------------------------------------------------------------
//
EXPORT_C void CGroupListSubscriptionItem::SetCreatedListL(
        RPrGrpInfoImpArray* aGroupList )
    {
    TRACE_1( _L("CGroupListSubscriptionItem::SetCreatedListL() aGroupList Count=%d"), aGroupList->Count() );
    // we took ownership to the given list
    RPrGrpInfoImpArray* tmp = aGroupList;
    CleanupDeletePushL( tmp );

    // see also SetNewListL.

    // the list is already sorted. when a copy was made in datacacheimp, the
    // InsertInOrder method was used
    TLinearOrder<CPresentityGroupInfoImp>
        linearOrder( CPresentityGroupInfoImp::GroupIdLinearOrder );

    // update the list of created and updated groups
    for ( TInt i = 0; i < tmp->Count(); i++ )
        {
        // compare against current list
        CPresentityGroupInfoImp* info = (*tmp)[ i ];
        TInt pos = iCurrentList->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.
            iCurrentList->InsertInOrderL( info, linearOrder );
            ( *tmp )[ i ] = NULL;
            iCreated->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
            (*iCurrentList)[ pos ]->SetGroupDisplayNameL( info->GroupDisplayName() );

            // found in current list, so it must be an updated list name
            iUpdated->InsertInOrderL( (*iCurrentList)[ 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 );
    }

// ---------------------------------------------------------------------------
// CGroupListSubscriptionItem::SetDeletedListL
// ---------------------------------------------------------------------------
//
EXPORT_C void CGroupListSubscriptionItem::SetDeletedListL(
        RPrGrpInfoImpArray* aGroupList )
    {
    TRACE_1( _L("CGroupListSubscriptionItem::SetDeletedListL() aGroupList Count=%d"), aGroupList->Count() );
    // we will eventually take ownership to this
    RPrGrpInfoImpArray* tmp = aGroupList;
    CleanupDeletePushL( tmp );

    // see also SetNewListL.

    // the list is already sorted. when a copy was made in datacacheimp, the
    // InsertInOrder method was used
    TLinearOrder<CPresentityGroupInfoImp>
        linearOrder( CPresentityGroupInfoImp::GroupIdLinearOrder );

    // remove the deleted ones from the current list
    for ( TInt i = 0; i < tmp->Count(); i++ )
        {
        // compare against current list
        CPresentityGroupInfoImp* info = (*tmp)[ i ];
        TInt pos = iCurrentList->FindInOrder( info, linearOrder );

        // found in current list, so it must be a deleted list name
        if ( pos != KErrNotFound )
            {
            // remove from current list
            delete (*iCurrentList)[ pos ];
            iCurrentList->Remove( pos );
            }
        }

    // the given list becomes the new list of
    // deleted ones
    delete iDeleted;
    iDeleted = tmp;
    CleanupStack::Pop( tmp );
    iSubscriptionState->SetDataStateL( MXIMPDataSubscriptionState::EDataAvailable );
    }

// ---------------------------------------------------------------------------
// CGroupListSubscriptionItem::Clean
// ---------------------------------------------------------------------------
//
EXPORT_C void CGroupListSubscriptionItem::Clean()
    {
    TRACE( _L("CGroupListSubscriptionItem::Clean()") );
    // empty the lists.
    // the lists must stay valid for use

    // iCreated and iUpdated are collection from currentlist. Do not delete items.
    // iDeleted is only place for items. Delete those.

    iCreated->Reset();
    iUpdated->Reset();
    iDeleted->Close();
    }

// ---------------------------------------------------------------------------
// CGroupListSubscriptionItem::CleanExpired()
// ---------------------------------------------------------------------------
//
void CGroupListSubscriptionItem::CleanExpired()
    {

    }
// End of file