/*
* 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
 *
*/


#ifndef CCABLOCKINGMANAGER_H
#define CCABLOCKINGMANAGER_H

// INCLUDES
#include "MCABlocking.h"
#include "MCAImpsImClient.h"
#include "MCASettingsObserver.h"
#include "MCASettings.h"
#include "TStorageManagerGlobals.h"
#include "PublicEngineDefinitions.h"
#include "PrivateEngineDefinitions.h"
#include "MCABackgroundTask.h"
#include "mcastoredcontactsobserver.h"

#include "ImpsImCli.h"

#include <e32base.h>

// FORWARD DECLARATIONS
class CCARequestMapper;
class MCAStoredContacts;
class MCAImpsFactory;

// CLASS DECLARATION

/**
 *  Blocking manager handles the blocking and granting
 *  ( user ) operations.
 *
 *  @lib CAEngine.lib
 *  @since 1.2
 */
class CCABlockingManager : public CBase,
            public MImpsBlockingHandler2,
            public MCABlocking,
            public MCASettingsObserver,
            public MCABackgroundTask,
            public MCAStoredContactsObserver
    {

    private: // internal enumerations

        // internal states for blocking manager
        enum TBlockingMgrState
            {
            // normal operation
            EStateNormal = 0,

            // deleting of grant list, response to request needs to
            // be handled differently
            EStateDeletingGrantList
            };

    public:

        /**
         * Static constructor.
         * @param aImpsImServer is the API to the blocking services.
         * @param aRequestMapper is the pointer to the request mapper.
         *        Used in mapping requests to responses.
         * @param aSettingsManager The settings API
         */
        IMPORT_C static CCABlockingManager* NewL(
            MCAImpsFactory* aIMPSFactory,
            CCARequestMapper* aRequestMapper,
            MCASettings* aSettingsManager
        );

        /**
        * Virtual Destructor.
        */
        IMPORT_C virtual ~CCABlockingManager();

    protected: // Inherited from MCABlocking

    	/**
         * From MCABlocking
         * @see MCABlocking::SetAppUiExitFlag.
         */    	
    	void SetAppUiExitFlag( TBool aFlag );
    	
    	/**
         * From MCABlocking
         * @see MCABlocking::GetBlockedListFromServerL.
         */
        TInt GetBlockedListFromServerL();

        /**
         * From MCABlocking
         * @see MCABlocking::BlockedList.
         */
        const CDesCArray* BlockedList();

        /**
         * From MCABlocking
         * @see MCABlocking::InsertL.
         */
        TInt InsertL( const CDesCArray* aBlockList,
                      const CDesCArray* aGrantList,
                      TBool aForceUpdate = EFalse );

        /**
         * From MCABlocking
         * @see MCABlocking::RemoveL.
         */
        TInt RemoveL( const CDesCArray* aBlockList,
                      const CDesCArray* aGrantList,
                      TBool aForceUpdate = EFalse );

        /**
         * From MCABlocking
         * @see MCABlocking::IsContactBlocked
         */
        TBool IsContactBlocked( const TDesC& aContact,
                                TBool aUseGrant = EFalse ) const;

        /**
         * From MCABlocking
         * @see MCABlocking::ContactListChangedL
         */
        void ContactListChangeL( TBool aUpdateInProgress );

        /**
         * From MCABlocking
         * @see MCABlocking::SetTemporaryGrantL
         */
        TInt SetTemporaryGrantL( const TDesC& aContact, TBool aOn );


    protected:  // from MImpsBlockingHandler

        /**
         * Handle response to getblockedlist request.
         * @param aBlockedList list of blocked users.
         * @param aBlockedListInUse is blocked list use or not.
         * @param aGrantedList list of granted users.
         * @param aGrantedListInUse is granted list use or not.
         */
        virtual void GetBlockedListResponseL(
            const MDesCArray* aBlockedList,
            TBool aBlockedListInUse,
            const MDesCArray* aGrantedList,
            TBool aGrantedListInUse,
            TImpsCspIdentifier& aCspId );

        /**
         * Server call back for handling successful operation requests.
         * @param aOperationId to map responses to the requests.
         * @param aStatus error code. KErrNone if successful.
         */
        virtual void HandleCompleteL(
            TInt aOperationId,
            TImpsCspIdentifier& aCspId );

    protected: // From MCASettingsObserver

        /**
         * Handles setting changes.
         * @param aChangedSettingEnum specifies the changed setting.
         * @since 2.1
         */
        void HandleSettingsChangeL( TInt aChangedSettingEnum );

    protected: //From MCABackgroundTask

        /**
         * This is the place where Block/GrantList synchronisation is started
         * after getting online event
         * @param aSubTask is the number of subtask, its counting down
         * @see MCABackgroundTask::HandleBackgroundTaskL
         */
        void HandleBackgroundTaskL( TInt aSubTask );

    protected: // From MCAStoredContactsObserver

        /**
         * @see MCAStoredContactsObserver
         */
        void HandleContactDelete( const TDesC& aContactId );

        /**
         * @see MCAStoredContactsObserver
         */
        void HandleAddition( MCAContactList& aList, MCAStoredContact& aContact );

        /**
         * @see MCAStoredContactsObserver
         */
        void HandleChange( MCAContactList* aList,
                           MCAStoredContact* aContact,
                           TStorageManagerGlobals::TCAObserverEventType aEventType,
                           TBool aUserIdChanged );

    public:  // new methods

        /**
         * If network state changes, BlockingManager state should be updated
         * by calling this method.
         * @param aState New state.
         * @param aUseGrant ETrue if grant list can be used.
         */
        void HandleNetworkStateChange( TNetworkState aState,
                                       TBool aCanUseGrant );

    private: // new methods

        /**
         * Does the actual handling
         */
        virtual void DoGetBlockedListResponseL(
            const MDesCArray* aBlockedList,
            TBool aBlockedListInUse,
            const MDesCArray* aGrantedList,
            TBool aGrantedListInUse );

        /**
         * Does the actual handling
         */
        virtual void DoHandleCompleteL(
            TInt aOperationId,
            TInt aStatus );

        /**
         * Evaluate current grantlist handling strategy
         * @return ETrue if grant list is in use
         */
        TBool GrantListInUse();

        /**
         * Clear the current grant list.  Used internally when
         * strategy is to allow nobody.
         */
        void ClearGrantListL( TBool aForceUpdate = EFalse );

        /**
         * Add given wv id to the internal block list
         * @param aId The wv id
         */
        void AddToBlockListL( const TDesC& aId );

        /**
         * Remove given wv id from the internal block list
         * @param aId The wv id
         */
        void RemoveFromBlockList( const TDesC& aId );

        /**
         * Check if given wv id is in the internal block list
         * @param aId The wv id
         * @return ETrue if the contact is in the list (is blocked)
         */
        TBool InternallyBlocked( const TDesC& aId ) const;

        /**
         * Add all friends to the internal grant list
         * @param aDoNotIncludeList, List of items which we do not want to
         *                           include from contact list.
         */
        void GrantFriendsL( CDesCArray* aDoNotIncludeList = NULL );

        /**
         * Insert or remove to grant or block list.
         * Leaves with KErrArgument if aRequest is not EBlockRequest
         * or EUnBlockRequest.
         * @param aInsertBlockList WV IDs to be inserted to blocklist.
         * @param aRemoveBlockList WV IDs to be removed from blocklist.
         * @param aInsertGrantList WV IDs to be inserted to grantlist.
         * @param aRemoveGrantList WV IDs to be removed from grantlist.
         * @param aAdditionalData A pointer to an array which is set to
         *                        CCARequest as additional data.
         * @param aRequest Request type, either block or unblock request.
         * @return error code.
         */
        TInt DoBlockRequestL( const CDesCArray* aInsertBlockList,
                              const CDesCArray* aRemoveBlockList,
                              const CDesCArray* aInsertGrantList,
                              const CDesCArray* aRemoveGrantList,
                              const CDesCArray* aAdditionalData,
                              TOperationRequests aRequest );

        /**
         *  Checks if contacts is granted or not
         *  @since 2.1
         *  @param aContactId, contact which is checked
         *  @return ETrue if granted, EFalse if not.
         */
        TBool IsContactGranted( const TDesC& aContact ) const;

        /**
        * Creates the CDesCArray from the source.
        * Ownership is transferred to caller!
        * @since 2.1
        * @param aSource Array to be copied
        * @return Array containing the same elements as source array
        */
        static CDesCArray* CloneArrayLC( const MDesCArray& aSource );

        /**
         * Creates the CDesCArray containing the items from arrayDiff that
         * are not on arrayTest
         * Ownership is transferred to caller!
         * @since 2.1
         * @param aArrayDiff Array whose differences are copied
         * @param aArrayTest Array to be tested on
         * @return Array containing the differences
         */
        static CDesCArray* CreateNeutralDiffLC( const MDesCArray& aArrayDiff,
                                                const MDesCArray& aArrayTest );



        /**
         *  Check if InsertL/RemoveL should be processed or not.
         *  @since 2.1
         *  @param aBlockList, List of wvids to block
         *  @param aGrantList, List of wvids to grant
         *  @param aForceUpdate Force update (ETrue) or not
         *  @return ETrue, if update is needed.
         */
        TBool NeedUpdate( const CDesCArray* aBlockList,
                          const CDesCArray* aGrantList,
                          TBool aForceUpdate );

        /**
         *  Add contacts to granted list.
         *  @param aInsertArray. Array of contacts to be
         *                       inserted to granted list.
         */
        void AddToGrantedListL( const MDesCArray& aInsertArray );

        /**
         *  Remove contacts from granted list and modify removeArray
         *  @param aRemoveArray Array of contacts to be removed.
         *                      Remove those contacts from aRemoveArray which
         *                      are not meant to be deleted. For example:
         *                      Those which are still in other lists.
         */
        void RemoveFromGrantedList( CDesCArray& aRemoveArray );

    private:    // constructors and destructors

        /**
         * Default constructor.
         * @param aStorage is the pointer to the storage side. Used in updating
         *        flags etc.
         * @param aImpsImServer is the API to the server side.
         * @param aRequestMapper is the pointer to the request mapper.
         *        Used in mapping requests to responses.
         */
        CCABlockingManager(
            MCAImpsFactory* aIMPSFactory,
            CCARequestMapper* aRequestMapper,
            MCASettings* aSettingsManager );

        /**
         * ConstructL method.
         */
        void ConstructL();

    private: // Data

        // Doesn't own. Pointer to the IMPS interface factory.
        MCAImpsFactory* iImpsFactory;

        // Doesn't own. Pointer to the request mapper.
        CCARequestMapper* iRequestMapper;

        // doesn't own, pointer to settings API
        MCASettings* iSettingsManager;

        // Owns. List of blocked users, returned via BlockedList
        CDesCArrayFlat* iBlockedList;

        // Owns. List of granted users, returned via BlockedList
        CDesCArrayFlat* iGrantedList;

        // Maps the GetBlockedListFromServerL to GetBlockedListResponseL.
        TInt iGetBlockedListOpId;

        // Flag to tell if background tasks are run or not.
        TBool iBackgroundTaskReady;

        // handle to contacts list interface
        MCAStoredContacts* iStoredContacts; // not owned

        // the used granting strategy
        MCASettings::TCASettingValues iStrategy;

        // internal state
        TBlockingMgrState iMgrState;

        // Is our list valid
        TBool iBlocklistIsValid;

        // Can Grant list be used.
        TBool iCanUseGrant;

        //
        TBool iUpdateInProgress;

        TBool iLoggedIn;
        
        TBool iAppUiExit;
    };

#endif // CCABLOCKINGMANAGER_H