/*

* 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:  Group handling utilities

*

*/

//INCLUDES

#include    "ImpsCSPAllErrors.h"

#include    "CCAGroupUtils.h"

#include    "chatngclient.hrh"

#include    "ChatDefinitions.h"

#include    "CAExternalInterface.h"

#include    "CCAAppUi.h"

#include    "ChatDebugPrint.h"

#include    "CCAGroupPropertiesDialog.h"

#include    "IMNoteMapper.h"

#include    "IMDialogUtils.h"

#include    "StringLoader.h"

#include    "CCAStatusPaneHandler.h"

#include    "CCAChatInfoArray.h"

#include    "CAArrayUtils.h"

#include    "CCAUISessionManager.h"

#include    "IMUtils.h"

#include    "CAUtils.h"

#include    "CCAApp.h"

#include    "CCAVariantFactory.h"

#include    "CCAContactSelectionDialog.h"

#include    "CCAUINGUtils.h"

#include    "CCAPCUtils.h"

#include    "MCAConversationMessage.h"

#include	"MCAProcessManager.h"

#include    "MCAGroupPC.h"

#include 	"MCAGroupUtilsPC.h"

#include    <chatNG.rsg>

#include    <chatNG.mbg>

#include    <impsgroupprops.h>

#include    <aknnotewrappers.h>

#include    <aknlists.h>

#include    <bautils.h>

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

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

// CCAGroupUtils::CCAGroupUtils

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

// might leave.

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

//

CCAGroupUtils::CCAGroupUtils( MCAViewSwitcher& aViewSwitcher )

        : iViewSwitcher( aViewSwitcher ),

        iCurrState( ESGCNone ),

        iPrevState( ESGCNone ),

        iScreenNamePtr( NULL, 0 )

    {

    }

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

// CCAGroupUtils::NewL

// Two-phased constructor.

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

//

CCAGroupUtils* CCAGroupUtils::NewLC( MCAViewSwitcher& aViewSwitcher )

    {

    CCAGroupUtils* temp = new( ELeave )CCAGroupUtils( aViewSwitcher );

    CleanupStack::PushL( temp );

    temp->ConstructL();

    return temp;

    }

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

// CCAGroupUtils::ResolveInviteConflictL

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

//

void CCAGroupUtils::ResolveInviteConflictL( const TDesC& aGroup,

                                            CDesCArray& aArray )

    {

    // get the banned and all user list  from pc

    TInt countInvite( aArray.MdcaCount() );

    if ( !countInvite )

        {

        //no possible conflicts

        return;

        }

    iAppUi->ShowWaitDialogLC( R_QTN_GEN_CHAT_NOTE_PROCESSING, ETrue );

    TInt err( KErrNone );

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

    CleanupStack::PushL( banned );

    // Check server capabilities for group reject list

    if ( iAppUi->UISessionManager().IsSupported( CCAUISessionManager::EGroupRejectList ) )

        {

        // If supported, fetch list

        err = iGroupUtilsPC->GetRejectListL( *banned, aGroup );

        }

    if ( err == ECSPInsufficientGroupPrivileges )

        {

        //not enough group rights

        CleanupStack::PopAndDestroy( 2 ); // banned, wait

        return;

        }

    User::LeaveIfError( err );

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

        {

        //no possible conflict , nothing to do, just cleanup

        CleanupStack::PopAndDestroy( 2 ); // banned, wait

        return;

        }

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

    CleanupStack::PushL( userList );

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

    CleanupStack::PushL( screenNames );

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

    CleanupStack::PushL( moders );

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

    CleanupStack::PushL( admins );

    err = iGroupUtilsPC->GetMembersL( *userList,

                                      *screenNames,

                                      *moders,

                                      *admins, aGroup );

    User::LeaveIfError( err );

    CDesCArray* newBanned = CAArrayUtils::CloneArrayLC( *banned );

    CDesCArray* newUserlist = CAArrayUtils::CloneArrayLC( *userList );

    TInt bannedCount( banned->MdcaCount() );

    TInt pos( KErrNotFound );

    TInt userlistInUse = userList->MdcaCount();

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

        {

        pos = CAUtils::NeutralFind( aArray, banned->MdcaPoint( i ) );

        if ( pos != KErrNotFound )

            {

            //we have a conflict to resolve

            HBufC* prompt = StringLoader::LoadLC( R_QTN_CHAT_INVITE_REMOVE_BANNED,

                                                  iGroupUtilsPC->GetIdentificationL( banned->MdcaPoint( i ) ) );

            TInt ret( IMDialogUtils::DisplayQueryDialogL( R_GENERIC_YES_NO_CONFIRMATION_QUERY,

                                                          *prompt ) );

            CleanupStack::PopAndDestroy( prompt );

            if ( ( ret == EAknSoftkeyOk ) || ( ret == EAknSoftkeyYes )  )

                {

                //lets remove from the banned list

                newBanned->Delete( i );

                if ( userlistInUse )

                    {

                    newUserlist->AppendL( banned->MdcaPoint( i ) );

                    }

                }

            else

                {

                //lets removed from the invitation list

                aArray.Delete( pos );

                }

            }

        }

    if ( newBanned->MdcaCount() != bannedCount )

        {

        //we need to update group props

        CDesCArray* newAdminlist = CAArrayUtils::CloneArrayLC( *admins );

        iGroupUtilsPC->UpdateGroupMembersL(

            aGroup,

            *admins, *newAdminlist,

            *userList, *newUserlist,

            *banned, *newBanned );

        CleanupStack::PopAndDestroy( newAdminlist );

        }

    // newUserlist , newBanned, admins, moders, screenNames

    CleanupStack::PopAndDestroy( 8 ); // banned, userlist, wait

    }

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

// CCAGroupUtils::~CCAGroupUtils

// Destructor

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

//

CCAGroupUtils::~CCAGroupUtils()

    {

    delete iGroupId;

    delete iAsyncCb;

    delete iJoinGroupId;

    if ( iWait.IsStarted() )

        {

        iWait.AsyncStop();

        }

    delete iAsyncGroupId;

    delete iAsyncScreenName;

    }

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

// CCAGroupUtils::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCAGroupUtils::ConstructL()

    {

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

    iGroupPC = iAppUi->GetProcessManager().GetGroupInterface();

    iGroupUtilsPC = iAppUi->GetProcessManager().GetGroupUtilsInterface() ;

    }

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

// CCAGroupUtils::EditChatGroupPropertiesL

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

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

//

TInt CCAGroupUtils::EditChatGroupPropertiesL( const TDesC& aGroupId )

    {

    CHAT_DP_FUNC_ENTER( "EditChatGroupPropertiesL" );

    TBool areItemsEdited( EFalse );

    // create lists

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

    CleanupStack::PushL( userList );

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

    CleanupStack::PushL( screenNames );

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

    CleanupStack::PushL( moders );

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

    CleanupStack::PushL( admins );

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

    CleanupStack::PushL( rejected );

    TInt err( KErrNone );

    iAppUi->ShowWaitDialogL( R_QTN_GEN_CHAT_NOTE_PROCESSING, ETrue );

    TRAPD( leave, err = iGroupUtilsPC->GetGroupDataL( aGroupId, *userList, *screenNames,

                                                      *moders, *admins, *rejected ) );

    iAppUi->DismissWaitDialogL( leave );

    if ( err != KErrNone )

        {

        IMNoteMapper::ShowNoteL( err );

        CleanupStack::PopAndDestroy( 5, userList ); // rejected, admins,

        // moders, screenNames, userList

        return EAknSoftkeyCancel;

        }

    iGroupUtilsPC->MoveOwnIdToFirstL( *admins );

    // store the original arrays

    // (we'll ignore screennames and moderators)

    CDesCArray* oldUserList = CAArrayUtils::CloneArrayLC( *userList );

    CDesCArray* oldAdmins = CAArrayUtils::CloneArrayLC( *admins );

    CDesCArray* oldRejected = CAArrayUtils::CloneArrayLC( *rejected );

    // construct the groupproperties dialog

    CCAGroupPropertiesDialog* groupPropDialog =

        new( ELeave )CCAGroupPropertiesDialog(

        *iViewSwitcher.CAStatusPane(),

        ETrue,

        *userList,

        *admins,

        *rejected,

        aGroupId,

        areItemsEdited );

    CleanupStack::PushL( groupPropDialog );

    groupPropDialog->ConstructL( R_CHATCLIENT_MENUBAR_CHAT_PROPERTIES_VIEW );

    // launch the dialog

    CleanupStack::Pop( groupPropDialog );

    TInt result( groupPropDialog->ExecuteLD( R_CHATCLIENT_GROUPPROPERTIES_DLG ) );

    CHAT_DP( D_CHAT_LIT(

                 "CCAGroupUtils::EditChatGroupPropertiesL areItemsEdited: %d" ),

             areItemsEdited );

    if ( ( result == EAknSoftkeyDone || result == EAknSoftkeyYes ) && areItemsEdited )

        {

        // Display wait note. Move this to utils side.

        iAppUi->ShowWaitDialogL( R_QTN_GEN_NOTE_SAVING, ETrue );

        // Update properties

        TInt err( KErrNone );

        TRAP( leave, err = iGroupUtilsPC->ProcessEditedGroupPropertiesL(

                               aGroupId, *oldAdmins, *admins, *oldUserList, *userList,

                               *oldRejected, *rejected ) );

        iAppUi->DismissWaitDialogL( leave );

        if ( err != KErrNone )

            {

            IMNoteMapper::ShowNoteL( err );

            CleanupStack::PopAndDestroy( 8, userList );

            return EAknSoftkeyCancel;

            }

        }

    else if ( result == EAknSoftkeyExit )

        {

        CEikonEnv::Static()->EikAppUi()->HandleCommandL( EChatClientCmdExit );

        }

    CleanupStack::PopAndDestroy( 8, userList );

    CHAT_DP_FUNC_DONE( "EditChatGroupPropertiesL" );

    return result;

    }

// utilsside_complete

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

// CCAGroupUtils::AskScreenNameL

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

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

//

TInt CCAGroupUtils::AskScreenNameL( TDes& aScreenName )

    {

    // don't call this directly, call ScreenNameQueryL instead

    // make sure we're not capturing

    TBool wasCapturing = iAppUi->AreEventsCaptured();

    iAppUi->ReleaseCapturingL();

    // ask for the screenname

    TInt result = IMDialogUtils::DisplayTextQueryDialogL( aScreenName,

                                                          R_CHATCLIENT_CLIST_SN_PROMPT,

                                                          R_CHATCLIENT_CLIST_SN_QUERY,

                                                          ETrue // T9

                                                        );

    if ( wasCapturing )

        {

        // restore capturing

        iAppUi->CaptureEventsL();

        }

    return result;

    }

// pcside_partially ..impact has to be analysed

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

// CCAGroupUtils::CreateNewChatL

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

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

//

HBufC* CCAGroupUtils::CreateNewChatL( TInt aResourceId, const TUid aViewId,

                                      TBool aContactFound, TEnumsPC::TListSelectionType aSelType,

                                      TInt aSelectedListIndex   )

    {

    CHAT_DP_FUNC_ENTER( "CreateNewChatL" );

    if ( !iAppUi->UISessionManager().IsLoggedIn() )

        {

        iAppUi->UISessionManager().LoginL( MCAUiLoginCmdCB::ELogin );

        if ( !iAppUi->UISessionManager().IsLoggedIn() )

            {

            // Still not logged in

            // Can't continue

            return NULL;

            }

        }

    if ( IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_SIMPLE_GROUP_CREATION ) )

        {

        // simplified new school group creation

        CHAT_DP_FUNC_DONE( "CreateNewChatL" );

        return CreateNewChatSimpleL( aResourceId, aViewId , aContactFound, aSelType, /*aOnlineContacts*/ aSelectedListIndex );

        }

    else

        {

        // normal old school group creation

        CHAT_DP_FUNC_DONE( "CreateNewChatL" );

        return CreateNewChatNormalL( aResourceId, aViewId );

        }

    }

//pcside_partially

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

// CCAGroupUtils::CreateNewChatNormalL

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

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

//

HBufC* CCAGroupUtils::CreateNewChatNormalL(

    TInt aResourceId,

    const TUid aViewId )

    {

    CHAT_DP_FUNC_ENTER( "CreateNewChatNormalL" );

    TBool areItemsEdited( EFalse );

    // create lists

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

    CleanupStack::PushL( userList );

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

    CleanupStack::PushL( admins );

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

    CleanupStack::PushL( rejected );

    // add own wvid to admins list

    // Use new function for this

    iGroupUtilsPC->MoveOwnIdToFirstL( *admins );

    // note: groupprops must be at the top of the cleanupstack

    // so that we can get them out before call to creategroupl

    CImpsCommonGroupProps* groupProps = CImpsCommonGroupProps::NewL();

    CleanupStack::PushL( groupProps );

    CImpsPrivateGroupProps* privateProps = CImpsPrivateGroupProps::NewL();

    CleanupStack::PushL( privateProps );

    CImpsCommonGroupProps* newGroupProps = CImpsCommonGroupProps::NewL();

    CleanupStack::PushL( newGroupProps );

    CImpsPrivateGroupProps* newPrivateProps = CImpsPrivateGroupProps::NewL();

    CleanupStack::PushL( newPrivateProps );

    // construct and launch the groupproperties dialog

    CCAGroupPropertiesDialog* groupPropDialog =

        new( ELeave )CCAGroupPropertiesDialog(

        *iViewSwitcher.CAStatusPane(),

        /**groupProps, *privateProps, *newGroupProps, *newPrivateProps,*/

        EFalse,

        *userList, *admins, *rejected,

        KNullDesC,

        areItemsEdited );

    CleanupStack::PushL( groupPropDialog );

    groupPropDialog->ConstructL( R_CHATCLIENT_MENUBAR_CHAT_PROPERTIES_VIEW );

    CleanupStack::Pop( groupPropDialog );

    TInt result( groupPropDialog->ExecuteLD(

                     R_CHATCLIENT_GROUPPROPERTIES_DLG ) );

    CHAT_DP( D_CHAT_LIT(

                 "CCAGroupUtils::CreateNewChatNormalL areItemsEdited: %d" ),

             areItemsEdited );

    HBufC* groupId = NULL;

    if ( result == EAknSoftkeyDone || result == EAknSoftkeyYes )

        {

        CCAUINGUtils::SetTitleL( aResourceId, aViewId );

        // ask screenname query before creation, or re-use alias

        TBool joinGroup( EFalse );

        // fetch the default or recently used screen name pointer

        iScreenNamePtr.Set( iAppUi->ScreenNamePtr()->Des() );

        TInt ret = ScreenNameQueryL( iScreenNamePtr );

        if ( ret == EAknSoftkeyDone || ret == EAknSoftkeyOk )

            {

            CDesCArray* noteTexts = new( ELeave ) CDesCArrayFlat(

                KArrayGranularity );

            CleanupStack::PushL( noteTexts );

            noteTexts->AppendL( newGroupProps->GroupName() );

            noteTexts->AppendL( iScreenNamePtr );

            HBufC* waitMsg = StringLoader::LoadLC(

                                 RSC_CHAT_JOIN_WAIT, *noteTexts );

            iAppUi->ShowWaitDialogL( *waitMsg, ETrue );

            CleanupStack::PopAndDestroy( 2, noteTexts ); // waitMsg, noteTexts

            joinGroup = ETrue;

            }

        else

            {

            iAppUi->ShowWaitDialogL( R_QTN_GEN_CHAT_NOTE_PROCESSING, ETrue );

            }

        // check the autodeletion variation flag

        if ( IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_GROUP_AUTODELETE ) )

            {

            newGroupProps->SetAutoDelete( EImpsPropYes );

            }

        // CreateGroupL takes the ownership of the properties

        CleanupStack::Pop( 2, newGroupProps ); // newPrivateProps, newGroupProps

        CleanupStack::PopAndDestroy( 2, groupProps ); // privateProps, groupProps

        TInt error( 0 );

        TBool whisperingAllowed =

            IMUtils::IntResourceValueL(

                RSC_CHAT_VARIATION_GROUP_WHISPER ) == 1;

        TRAPD( err, groupId = iGroupUtilsPC->CreateGroupSimpleL( iScreenNamePtr,

                                                                 joinGroup,

                                                                 whisperingAllowed,

                                                                 error ) );

        // if CreateGroupL returns NULL, it couldn't create the group

        if ( groupId )

            {

            // Delete old one. No need to store it.

            // Cannot put groupId to CleanupStack because if PushL leaves then

            // wait note would be shown forever

            delete iGroupId;