/*

* 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:  UI side blocker class

 *

*/

// INCLUDE FILES

#include    "CCABlockingUI.h"

#include    "IMNoteMapper.h"

#include	"IMDialogUtils.h"

#include    "ChatDefinitions.h"

#include    "chatdebugprint.h"

#include    "avkon.hrh"

#include    "ImpsCSPAllErrors.h"

#include    "CCAAppUi.h"

#include    "MCAServerContactsArrayPC.h"

#include    "CAArrayUtils.h"

#include    "IMUtils.h"

#include    "CAUtils.h"

#include    "CCAPCUtils.h"

#include	"CCABlockingDialog.h"

#include	"chatngclient.hrh"

#include	"CCAAppUi.h"

#include    "CCAApp.h"

#include	"CCAStatusPaneHandler.h"

#include    "CCAContactEditor.h"

#include	"CCAVariantFactory.h"

#include	"CCAContactSelectionDialog.h"

#include    "ccasyncchecker.h"

#include    "impsbuilddefinitions.h"

#include    <chatNG.rsg>

#include    <eikenv.h>

#include	<hlplch.h>

#include    <StringLoader.h>

#include    <aknnotewrappers.h>

#include    "CCAServerContactsArrayPC.h"

#include    "MCASettingsPC.h"

#include 	"MCAProcessManager.h"

#include  	"MCABlockingPC.h"

#include <csxhelp/imng.hlp.hrh>

// The Settings have been moved to Cenrep (also retained in the Resource file),

// so the enums for keys and central repository header is added here

#include 	"VariantKeys.h"

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

_LIT( KMyTab, "\t" );

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

// might leave.

CCABlockingUI::CCABlockingUI( MCABlockingPC* aBlockingPC )

        : iBlockingPC( aBlockingPC ),

        iDialogShutter( EFalse )

    {

    }

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

// CCABlockingUI::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCABlockingUI::ConstructL()

    {

    iAppUi = static_cast< CCAAppUi* >( CCoeEnv::Static()->AppUi() );

    iMainViewArrayPC = iAppUi->GetProcessManager().GetArrayInterface();

    iBlockingPC->RegisterBackgroundObserver( this );

    iTextualInputMode = IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_USERID_TEXTUAL_INPUTMODE );

    }

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

// CCABlockingUI::NewL

// Two-phased constructor.

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

//

CCABlockingUI* CCABlockingUI::NewL( MCABlockingPC* aBlockingPC )

    {

    CCABlockingUI* self = new( ELeave ) CCABlockingUI( aBlockingPC );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CCABlockingUI::NewL

// Two-phased constructor.

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

//

CCABlockingUI* CCABlockingUI::NewLC( MCABlockingPC* aBlockingPC )

    {

    CCABlockingUI* self = new( ELeave ) CCABlockingUI( aBlockingPC );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCABlockingUI::~CCABlockingUI

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

//

CCABlockingUI::~CCABlockingUI()

    {

    CHAT_DP( D_CHAT_LIT( "CCABlockingUI::~CCABlockingUI \

                                     before delete iBlockingDialog:%d" ),

             iBlockingDialog );

    if ( iBlockingPC )

        {

        iBlockingPC->UnRegisterBackgroundObserver( );

        }

    delete iOldTitle;

    }

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

// CCABlockingUI::DisplayBlockedListL

// (other items were commented in a header).

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

//

void CCABlockingUI::DisplayBlockedListL( TBool aDontShowTabGroup /*= EFalse */ )

    {

    CHAT_DP_FUNC_ENTER( "DisplayBlockedListL" );

    switch ( iBlockingPC->GetBackgroundStatus() )

        {

        case TEnumsPC::ECompleted:

            {

            //we have a list

            break;

            }

        case TEnumsPC::EFailedStatus:

        case TEnumsPC::EUnknownStatus:

        case TEnumsPC::ECancelled:

            {

            //we dont have a list, but we can try again

            //show the wait dialog immediately

            iAppUi->ShowWaitDialogL( R_CHAT_BLOCK_FETCHING, ETrue );

            // Getting blocked members

            // We have to trap the get-method, because we need to propagate the

            // CSP errors forward to the wait dialog dismissal logic.

            TRAPD( err, iBlockingPC->GetBlockedListFromServerL() );

            iAppUi->DismissWaitDialogL( err );

            break;

            }

        case KErrNotFound:

        case TEnumsPC::EIdleStarted:

        case TEnumsPC::EStarting:

        case TEnumsPC::EWaiting:

            {

            //we have are getting the list, its time to wait

            //show the wait dialog immediately

            iAppUi->ShowWaitDialogL( R_CHAT_BLOCK_FETCHING, ETrue );

#ifdef _DEBUG

            if ( iFetchOperation != CCABlockingUI::EUnknown )

                {

                CHAT_DP( D_CHAT_LIT( "CCABlockingUI::DisplayBlockedListL \

                                 previous operation is waiting:%d" ),

                         iFetchOperation );

                }

#endif // _DEBUG

            iFetchOperation = EShowBlockList;

            iWaiting = ETrue;

            return;

            }

        default:

            {

            //we should not be here

            break;

            }

        }

    // dismiss the wait dialog

    iAppUi->DismissWaitDialogL( KErrNone );

    iWaiting = EFalse;

    iBlockingPC->GetBlockedMembersL( KMyTab );

    iSelectedItem = KErrNotFound;

    if ( iBlockingDialog )

        {

        delete iBlockingDialog;

        iBlockingDialog = NULL;

        }

    //preserve title pane text

    BackupTitleL();

    CleanupStack::PushL( TCleanupItem( CCABlockingUI::RestoreTitle, this ) );

    iBlockingArray = &( iBlockingPC->GetServerContactsArray() );

    iBlockingDialog = CCABlockingDialog::NewL( iSelectedItem, iBlockingArray,

                                               R_CHATCLIENT_MENUBAR_BLOCKING_DIALOG,

                                               R_CHATCLIENT_MENUBAR_BLOCKING_DIALOG2,

                                               this,

                                               aDontShowTabGroup

                                             );

    // CodeScanner warning ignored because iBlockingDailog is not owned by us

    // and it is destroyed automatically in ExecuteLD

    if ( iBlockingDialog->ExecuteLD( R_BLOCK_DIALOG ) == EChatClientCmdExit ) // CSI: 50 # See comment above

        {

        // Handle exit command

        iBlockingDialog = NULL;

        iAppUi->HandleCommandL( EChatClientCmdExit );

        }

    iBlockingDialog = NULL;

    CleanupStack::PopAndDestroy();

    CHAT_DP_FUNC_DONE( "DisplayBlockedListL" );

    }

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

// CCABlockingUI::DisplayUnblockListQueryL

// (other items were commented in a header).

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

//

void CCABlockingUI::DisplayUnblockListQueryL()

    {

    CHAT_DP_FUNC_ENTER( "DisplayUnblockListQueryL" );

    switch ( iBlockingPC->GetBackgroundStatus( ) )

        {

        case TEnumsPC::ECompleted:

            {

            //we have a list

            break;

            }

        case TEnumsPC::EFailedStatus:

        case TEnumsPC::EUnknownStatus:

        case TEnumsPC::ECancelled:

            {

            //we dont have a list, but we can try again

            //display the wait dialog immediately

            iAppUi->ShowWaitDialogL( R_CHAT_BLOCK_FETCHING, ETrue );

            //Getting blocked members

            // We have to trap the get-method, because we need to propagate the

            // CSP errors forward to the wait dialog dismissal logic.

            TRAPD( err, iBlockingPC->GetBlockedListFromServerL() );

            iAppUi->DismissWaitDialogL( err );

            break;

            }

        case KErrNotFound:

        case TEnumsPC::EIdleStarted:

        case TEnumsPC::EStarting:

        case TEnumsPC::EWaiting:

            {

            //we are getting the list, its time to wait

            //display the wait dialog immediately

            iAppUi->ShowWaitDialogL( R_CHAT_BLOCK_FETCHING, ETrue );

#ifdef _DEBUG

            if ( iFetchOperation != CCABlockingUI::EUnknown )

                {

                CHAT_DP( D_CHAT_LIT( "CCABlockingUI::DisplayUnblockListQueryL \

                                 previous operation is waiting:%d" ),

                         iFetchOperation );

                }

#endif // _DEBUG

            iFetchOperation = EShowUnblockList;

            iWaiting = ETrue;

            return;

            }

        default:

            {

            //we should not be here

            break;

            }

        }

    // dismiss the wait dialog

    iAppUi->DismissWaitDialogL( KErrNone );

    iWaiting = EFalse;

    MCAServerContactsArrayPC* blockedMembers = iBlockingPC->GetBlockedMembersLC( KIconTabulator );

    //Creating index array that tells what indexes are selected or not

    CArrayFixFlat<TInt>* indexArray =

        new ( ELeave ) CArrayFixFlat<TInt>( KArrayGranularity );

    CleanupStack::PushL( indexArray );

    //Creating list of unblocked users

    CDesCArrayFlat* unBlockList =

        new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

    CleanupStack::PushL( unBlockList );

    //Display pop up list

    TInt result( IMDialogUtils::DisplayListQueryDialogL( indexArray,

                                                         blockedMembers,

                                                         R_CHAT_UNBLOCK_LIST_QUERY ) );

    if ( result == EAknSoftkeyOk )

        {

        TInt blockedMembersCount( blockedMembers->MdcaCount() );

        TInt count( indexArray->Count() );

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

            {

            TInt deletedIndex( indexArray->At( i ) );

            if ( deletedIndex >= blockedMembersCount )

                {

                deletedIndex = blockedMembersCount - 1;

                }

            // unBlockList is those persons who are going to be unblocked

            unBlockList->AppendL( iBlockingPC->GetWvIdL( KIconTabulator,

                                                         deletedIndex ) );

            }

        // just a check

        if ( unBlockList->MdcaCount() > 0 )

            {

            iAppUi->ShowWaitDialogL( R_CHAT_BLOCK_REMOVING );

            TInt errorCode( KErrNone );

            TRAPD( err, errorCode = iBlockingPC->RemoveL( unBlockList, NULL ) );

            iAppUi->DismissWaitDialogL( err );

            if ( errorCode != KErrNone )

                {

                IMDialogUtils::DisplayErrorNoteL( errorCode );

                }

            }

        }

    CleanupStack::PopAndDestroy( 3 ); // unBlockList, indexArray, blockedMembers

    CHAT_DP_FUNC_DONE( "DisplayUnblockListQueryL" );

    }

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

// CCABlockingUI::DisplayBlockTextQueryL

// (other items were commented in a header).

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

//

void CCABlockingUI::DisplayBlockTextQueryL()

    {

    //Data pointer

    HBufC* data = HBufC::NewLC( KMaxWVIDLength );

    TPtr dataPtr( data->Des() );

    //Displaying text query dialog

    TInt result( IMDialogUtils::DisplayTextQueryDialogL( dataPtr,

                                                         R_CHATCLIENT_BLOCK_ENTER_PROMPT,

                                                         iTextualInputMode ? R_CHATCLIENT_BLOCK_ENTER : R_CHATCLIENT_BLOCK_ENTER2,

                                                         ETrue // T9

                                                       ) );

    if ( result == EAknSoftkeyOk || result == EAknSoftkeyDone )

        {

        // don't add a user which is already in our list

        const CDesCArray* blockList = iBlockingPC->GetBlockedList();

        TInt count = blockList->Count();

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

            {

            if ( 0 == CAUtils::NeutralCompare( *data,

                                               blockList->MdcaPoint( i ) ) )

                {

                CleanupStack::PopAndDestroy(); // data

                return;

                }

            }

        BlockUserL( *data );

        }

    CleanupStack::PopAndDestroy( data );

    }

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

// CCABlockingUI::BlockUserL

// (other items were commented in a header).

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

//

void CCABlockingUI::BlockUserL( const TDesC& aUserId )

    {

    // this cannot be called when the user is already on the list, because the

    // menu option will not be visible in such a case

    CDesCArray* blockArray = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

    CleanupStack::PushL( blockArray );

    blockArray->AppendL( aUserId );

    BlockMultipleUsersL( blockArray );

    CleanupStack::PopAndDestroy( blockArray );

    }

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

// CCABlockingUI::BlockUserL

// (other items were commented in a header).

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

//

void CCABlockingUI::BlockMultipleUsersL( const CDesCArray* aUserIds )

    {

    // If we go to block someone, we can not close the dialog

    if ( iBlockingDialog )

        iBlockingDialog->SetExitEnabled( EFalse );

    if ( !aUserIds )

        {

        // Set the value back when operation failed

        if ( iBlockingDialog )

            iBlockingDialog->SetExitEnabled( ETrue );

        User::Leave( KErrArgument );

        }

    TInt errorCode( KErrNone );

    // If contact list synch is not done. Wait for it.

    TInt removeBlocked = ( IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_BLOCKING ) == 0 );

    if ( removeBlocked && !CCASyncChecker::CheckSyncStateL() )

        {

        if ( iBlockingDialog )

            iBlockingDialog->SetExitEnabled( ETrue );

        return;

        }

    iAppUi->ShowWaitDialogL( R_CHAT_BLOCK_ADDING );

    if ( removeBlocked )

        {

        //we have to remove ids from the list first.

        TRAPD( err, RemoveIDsL( aUserIds ) );

        if ( err != KErrNone )

            {

            iAppUi->DismissWaitDialogL( err );

            if ( iBlockingDialog )

                iBlockingDialog->SetExitEnabled( ETrue );

            User::Leave( err );

            }

        }

    TRAPD( err, errorCode = iBlockingPC->InsertL( aUserIds, NULL ) );

    iAppUi->DismissWaitDialogL( err );

    // Set the value back when operation finished

    if ( iBlockingDialog )

        iBlockingDialog->SetExitEnabled( ETrue );

    CHAT_DP( D_CHAT_LIT( "CCABlockinManager::BlockUserL() err==%d" ), errorCode );

    if ( errorCode == KErrNone )

        {

        IMDialogUtils::DisplayNoteDialogL( R_CHATCLIENT_CNOTE_BLOCK );

        }

    else

        {

        if ( errorCode == ECSPInvalidParameter )

            {

            errorCode = ECSPUnknownUserId;

            }

        if ( aUserIds->MdcaCount() == 1 )

            {

            IMNoteMapper::ShowNoteL( errorCode, CCAPCUtils::DisplayId( aUserIds->MdcaPoint( 0 ) ) );

            }

        else

            {

            IMNoteMapper::ShowNoteL( errorCode );

            }

        }

    iBlockingPC->GetBlockedMembersL( KMyTab );

    if ( iBlockingDialog )

        {

        iBlockingDialog->HandleItemAdditionL();

        SetIndexAfterBlocking( aUserIds->Count() > 1,

                               aUserIds->MdcaPoint( 0 ) );

        }

    }

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

// CCAAppUi::CloseDialog

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

//

void CCABlockingUI::RestoreTitle( TAny* aInstance )

    {

    TRAPD( leave, static_cast<CCABlockingUI*>( aInstance )->DoRestoreTitleL() );

    if ( leave != KErrNone )

        {

        CActiveScheduler::Current()->Error( leave );

        }