/*

* Copyright (c) 2002-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:  Blocking manager handles the blocking and granting

 *

*/

// INCLUDES

#include "CCABlockingManager.h"

#include "CCARequest.h"

#include "CCARequestMapper.h"

#include "PrivateEngineDefinitions.h"

#include "ChatDebugPrint.h"

#include "CCAStorageManagerFactory.h"

#include "MCASettings.h"

#include "MCAStoredContact.h"

#include "MCAStoredContacts.h"

#include "MCAImpsFactory.h"

#include "impsbuilddefinitions.h"

#include "TStorageManagerGlobals.h"

#include "CAUtils.h"

#include "MCAPresence.h"

#include "MCAContactLists.h"

#include "CAPresenceManager.h"

#include "ccasyncchecker.h"

#include "mcacontactlist.h"

#include <badesca.h>

const TInt KBlockingMgrListGranularity = 10;

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

// C++ default constructor can NOT contain any code, that

// might leave.

//

CCABlockingManager::CCABlockingManager(

    MCAImpsFactory* aIMPSFactory,

    CCARequestMapper* aRequestMapper,

    MCASettings* aSettingsManager )

        :   iImpsFactory( aIMPSFactory ),

        iRequestMapper( aRequestMapper ),

        iSettingsManager( aSettingsManager ),

        iStrategy( MCASettings::EAll ),

        iMgrState( EStateNormal )

    {

    }

// Destructor

EXPORT_C CCABlockingManager::~CCABlockingManager()

    {

    if ( iBlockedList )

        {

        iBlockedList->Reset();

        delete iBlockedList;

        }

    if ( iGrantedList )

        {

        iGrantedList->Reset();

        delete iGrantedList;

        }

    }

// Two-phased constructor.

EXPORT_C CCABlockingManager* CCABlockingManager::NewL(

    MCAImpsFactory* aIMPSFactory,

    CCARequestMapper* aRequestMapper,

    MCASettings* aSettingsManager )

    {

    CCABlockingManager* self = new ( ELeave ) CCABlockingManager(

        aIMPSFactory,

        aRequestMapper,

        aSettingsManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Symbian OS default constructor can leave.

void CCABlockingManager::ConstructL()

    {

    iStoredContacts = CCAStorageManagerFactory::ContactListInterfaceL();

    iBlockedList = new ( ELeave ) CDesCArrayFlat( KBlockingMgrListGranularity );

    iGrantedList = new ( ELeave ) CDesCArrayFlat( KBlockingMgrListGranularity );

    // after this the strategy gets updated via observing mechanism

    iStrategy = ( MCASettings::TCASettingValues )

                iSettingsManager->Value( MCASettings::EReceiveIMessages );

    }

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

// CCABlockingManager::GetBlockedListRequestL()

// GetBlocked list

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

//

TInt CCABlockingManager::GetBlockedListFromServerL()

    {

    CHAT_DP_TXT( "CCABlockingManager::GetBlockedListFromServerL...starts" );

    iGetBlockedListOpId =  iImpsFactory->CreateImClientL()->GetBlockedListRequestL();

    // owned by request mapper

    CCARequest* request = iRequestMapper->CreateRequestL( iGetBlockedListOpId );    // CSI: 35 # Ownership is not transferred to caller.

    CHAT_DP_FUNC_DP( "GetBlockedListResponseL", "Going to HandleRequest" );

    iRequestMapper->HandleRequest( iGetBlockedListOpId, KErrNone );

    // set to 0 so we know that there is no request hanging.

    iGetBlockedListOpId = 0;

    TInt errorCode( request->ErrorCode() );

    iRequestMapper->RemoveRequest( request );

    if ( iMgrState == EStateNormal )

        {

        if ( iStrategy != MCASettings::EAll && iCanUseGrant )

            {

            CHAT_DP_FUNC_DP( "GetBlockedListResponseL",

                             "Copying grantlist" );

            switch ( iStrategy )

                {

                case MCASettings::EFriends:

                    {

#ifdef IMPS_CONTACT_FETCH_BACKGROUND

                    if( iAppUiExit )

                    	{

                    	return errorCode;

                    	}

                    // Can't grant friends if contact list

                    // sync is not done, wait for it if needed

                    if ( !CCASyncChecker::CheckSyncStateL() )

                        {

                        User::Leave( KErrNotReady );

                        }

#endif // IMPS_CONTACT_FETCH_BACKGROUND

                    CDesCArray* clone = CloneArrayLC( *iGrantedList );

                    GrantFriendsL();

                    // Check new ids to be granted

                    CDesCArray* diff = CreateNeutralDiffLC( *iGrantedList,

                                                            *clone );

                    // Check if clone contains more ids than we have friends

                    CDesCArray* diff2 = CreateNeutralDiffLC( *clone,

                                                             *iGrantedList );

                    iGrantedList->Reset();

                    // Remove grant from excess ids

                    RemoveL( NULL, diff2, ETrue );

                    // Add grant for new ids

                    InsertL( NULL, diff, ETrue );

                    GrantFriendsL(); // reset situation

                    CleanupStack::PopAndDestroy( 3, clone ); // clone, diff, diff2

                    break;

                    }

                case MCASettings::ENobody:

                    {

                    CDesCArray* clone = CloneArrayLC( *iGrantedList );

                    RemoveL( NULL, clone, ETrue );

                    CleanupStack::PopAndDestroy( clone );

                    break;

                    }

                default:

                    {

                    break;

                    }

                }

            }

        else if ( !iCanUseGrant )

            // This is done to get rid of grant list usage.

            {

            //if iGrantedList is empty, nothing to clean

            if ( iGrantedList && iGrantedList->MdcaCount() > 0 )

                {

                CDesCArray* clone = CloneArrayLC( *iGrantedList );

                RemoveL( NULL, clone, ETrue );

                CleanupStack::PopAndDestroy( clone );

                }

            }

        else if ( iCanUseGrant && iStrategy == MCASettings::EAll )

            {

            if( iAppUiExit )

            	{

            	return errorCode;

            	}

            InsertL( iBlockedList, NULL, ETrue );

            }

        }

    CHAT_DP_TXT( "CCABlockingManager::GetBlockedListFromServerL...over" );

    return errorCode;

    }

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

// CCABlockingManager::BlockedList()

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

//

const CDesCArray* CCABlockingManager::BlockedList()

    {

    return iBlockedList;

    }

// check if grant list in use according to the

// currently chosen strategy

TBool CCABlockingManager::GrantListInUse()

    {

    CHAT_DP_FUNC_ENTER( "GrantListInUse" );

    // grant list is always in use if we're not

    // accepting IMessages from all

    TBool retval( ETrue );

    if ( iStrategy == MCASettings::EAll || !iCanUseGrant )

        {

        // grant list not in use, everyone is accepted (except

        // that the blocking list overrides)

        retval = EFalse;

        CHAT_DP_TXT( "Grant list not in use!" );

        }

    CHAT_DP_FUNC_DONE( "GrantListInUse" );

    return retval;

    }

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

// CCABlockingManager::InsertL()

// Insert users to block or grant lists at server

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

//

TInt CCABlockingManager::InsertL(

    const CDesCArray* aBlockList,

    const CDesCArray* aGrantList,

    TBool aForceUpdate /* = EFalse */ )

    {

    if ( aGrantList )

        {

        CDesCArray* diff = CreateNeutralDiffLC( *aGrantList, *iGrantedList );

        TInt err( KErrNone );

        if ( NeedUpdate( aBlockList, diff, aForceUpdate ) && !iUpdateInProgress )

            {

            err = DoBlockRequestL( aBlockList, NULL, diff, NULL, aBlockList,

                                   EBlockRequest );

            if ( err == KErrNone )

                {

                AddToGrantedListL( *aGrantList );

                }

            }

        CleanupStack::PopAndDestroy( diff );

        return err;

        }

    else if ( NeedUpdate( aBlockList, aGrantList, aForceUpdate ) )

        {

        return DoBlockRequestL( aBlockList, NULL, aGrantList, NULL, aBlockList,

                                EBlockRequest );

        }

    return KErrNone;

    }

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

// CCABlockingManager::RemoveL()

// Remove users from block or grant lists at server

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

//

TInt CCABlockingManager::RemoveL(

    const CDesCArray* aBlockList,

    const CDesCArray* aGrantList,

    TBool aForceUpdate /* = EFalse */ )

    {

    if ( aGrantList )

        {

        CDesCArray* clone = CloneArrayLC( *aGrantList );

        RemoveFromGrantedList( *clone );

        TInt err( KErrNone );

        if ( NeedUpdate( aBlockList, clone, aForceUpdate )

             && !iUpdateInProgress )

            {

            err = DoBlockRequestL( NULL, aBlockList, NULL, clone, aBlockList,

                                   EUnBlockRequest );

            }

        CleanupStack::PopAndDestroy( clone );

        return err;

        }

    if ( NeedUpdate( aBlockList, aGrantList, aForceUpdate ) )

        {

        return DoBlockRequestL( NULL, aBlockList, NULL, aGrantList, aBlockList,

                                EUnBlockRequest );

        }

    return KErrNone;

    }

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

// CCABlockingManager::NeedUpdate

// If update is needed, return True

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

//

TBool CCABlockingManager::NeedUpdate( const CDesCArray* aBlockList,

                                      const CDesCArray* aGrantList,

                                      TBool aForceUpdate )

    {

    if ( !aForceUpdate )

        {

        if ( aGrantList )

            {

            if ( aGrantList->MdcaCount() == 0 )

                {

                return EFalse;

                }

            }

        else if ( aBlockList )

            {

            if ( aBlockList->MdcaCount() == 0 )

                {

                return EFalse;

                }

            }

        }

    return ETrue;

    }

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

// CCABlockingManager::GrantFriendsL()

// Insert friends to grant lists at server

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

//

void CCABlockingManager::GrantFriendsL(

    CDesCArray* aDoNotIncludeList /*= NULL*/ )

    {

    if( iAppUiExit )

    	{

    	return ;

    	}

    // add all friends to Grant list

    // the blocked list overrides this list anyway

    iGrantedList->Reset();

    // fetch the contacts from all lists in server

    CPtrCArray* wvids = new( ELeave )CPtrCArray( KArrayGranularity );

    CleanupStack::PushL( wvids );

    MCAPresence* presence = CAPresenceManager::InstanceL();

    MCAContactLists* listInterface = presence->ContactLists();

    TContactListsWrapper contactListIds;

    if ( listInterface )

        {

        contactListIds = listInterface->FetchServerContactListsL();

        }

    TInt count( contactListIds.MdcaCount() );

    TInt i;

    for ( i = 0; i < count; ++i )

        {

        listInterface->FetchServerContactsL( contactListIds.MdcaPoint( i ),

                                             *wvids );

        }

    count = wvids->MdcaCount();

    TBool doNotIncludeFlag( EFalse );

    for ( i = 0; i < count; ++i )

        {

        TPtrC id( wvids->MdcaPoint( i ) );

        if ( aDoNotIncludeList )

            {

            TInt count2( aDoNotIncludeList->MdcaCount() );

            for ( TInt j( 0 ); j < count2 && !doNotIncludeFlag; ++j )

                {

                if ( CAUtils::NeutralCompare( id,

                                              aDoNotIncludeList->MdcaPoint( j ) ) == 0 )

                    {

                    doNotIncludeFlag = ETrue;

                    aDoNotIncludeList->Delete( j );

                    }

                }

            }

        if ( !doNotIncludeFlag )

            {

            iGrantedList->AppendL( wvids->MdcaPoint( i ) );

            }

        else

            {

            doNotIncludeFlag = EFalse;

            }

        }

    CleanupStack::PopAndDestroy( wvids ); // wvids

    }

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

// CCABlockingManager::DoBlockRequestL()

// Execute block entity request with given arguments.

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

//

TInt CCABlockingManager::DoBlockRequestL( const CDesCArray* aInsertBlockList,

                                          const CDesCArray* aRemoveBlockList,

                                          const CDesCArray* aInsertGrantList,

                                          const CDesCArray* aRemoveGrantList,

                                          const CDesCArray* aAdditionalData,

                                          TOperationRequests aRequest )

    {

    // check argument validity

    if ( aRequest != EBlockRequest && aRequest != EUnBlockRequest )

        {

        User::Leave( KErrArgument );

        }

    TBool grantUsed = GrantListInUse();

    // Create the request but do not start the synchronous wait yet ( EFalse )

    CCARequest* request = iRequestMapper->CreateRequestL(

                              iImpsFactory->CreateImClientL()->BlockEntityRequestL(

                                  aInsertBlockList,

                                  aRemoveBlockList,

                                  ETrue,

                                  aInsertGrantList,

                                  aRemoveGrantList,

                                  grantUsed ),

                              EFalse );

    request->SetRequestType( aRequest );

    // empty array, so granularity of one

    CDesCArrayFlat* emptyArray = new( ELeave )CDesCArrayFlat( 1 );

    CleanupStack::PushL( emptyArray );

    // set correct array based on request to additional data

    const CDesCArray *tempArrayPtr = NULL;

    tempArrayPtr = emptyArray;

    if ( aAdditionalData )

        {

        tempArrayPtr = aAdditionalData;

        }

    request->SetAdditionalData( *tempArrayPtr );

    // Now when the request type and additional data is set we can

    // activate the synchronous wait

    request->StartWait();

    // Execution continues from here

    TInt errorCode( request->ErrorCode() );

    CHAT_DP( D_CHAT_LIT( "   Error code in DoBlockRequestL is %d" ), errorCode );

    iRequestMapper->RemoveRequest( request );

    CleanupStack::PopAndDestroy( emptyArray );

    return errorCode;

    }

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

// CCABlockingManager::IsContactBlocked

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

//

TBool CCABlockingManager::IsContactBlocked(

    const TDesC& aContact,

    TBool aUseGrant /*= EFalse*/ ) const

    {

    CHAT_DP_FUNC_ENTER( "IsContactBlocked" );

    CHAT_DP( D_CHAT_LIT(

                 "CCABlockingManager::IsContactBlocked - Checking contact %S" ),

             &aContact );

    MCAStoredContact* contact = iStoredContacts->FindAnyContact( aContact );

    // default to allowing the contact if it gets through

    // the switch-case

    TBool retVal( EFalse );

    MCASettings::TCASettingValues strategy =

        iCanUseGrant ? iStrategy : MCASettings::EAll;

    switch ( strategy )

        {

        case MCASettings::EAll:

            CHAT_DP_FUNC_DP( "IsContactBlocked", "Strategy is Grant all" );

                {

                // grant list not in use, allow all

                // but note the blocklist

                if ( !contact )

                    {

                    CHAT_DP_FUNC_DP( "IsContactBlocked", "Contact is not a friend" );

                    retVal = InternallyBlocked( aContact );

                    }

                else

                    {

                    CHAT_DP_FUNC_DP( "IsContactBlocked", "Contact is a friend" );

                    retVal = contact->IsBlocked();

                    }

                break;

                }

        case MCASettings::EFriends:

            {

            CHAT_DP_FUNC_DP( "IsContactBlocked", "Strategy is Grant friends" );

            // friends are granted according to block status

            if ( contact )

                {

                CHAT_DP_FUNC_DP( "IsContactBlocked", "Contact is a friend" );

                retVal = contact->IsBlocked();

                }

            else

                {