/*

* 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    "PublicEngineDefinitions.h"

#include    "CCAEngine.h"

#include    "CCAGroupUtilsPC.h"

#include    "ChatDebugPrint.h"

#include    "MCAGroupManagerInterface.h"

#include    "MCAGroupOperations.h"

#include    "MCAStoredGroups.h"

#include    "MCAExtendedStoredGroup.h"

#include    "CCAStorageManagerFactory.h"

#include    "CCAGroupPropertiesDialog.h"

#include    "ImpsCSPAllErrors.h"

#include    "MCASettings.h"

#include    "StringLoader.h"

#include    "CCAChatInfoArray.h"

#include    "CAArrayUtils.h"

#include    "IMUtils.h"

#include    "MCAInvite.h"

#include    "CAUtils.h"

#include    "MCAStoredContacts.h"

#include    "CCAStorageManagerFactory.h"

#include    "MCAConversationMessage.h"

#include	"MCAProcessManager.h"

#include    "CCAProcessManagerFactory.h"

#include    "CCAGroupPropertiesPC.h"

#include    "MCAChatInterface.h"

#include    <chatNG.rsg>

#include    <chatNG.mbg>

#include    <impsgroupprops.h>

#include    <aknnotewrappers.h>

#include    <aknlists.h>

#include    <bautils.h>

#include    "CCAPCUtils.h"

#include    "CCAUINGUtils.h"

#include    "ccagrouputilspc.h"

#include    <e32cmn.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"

#include 	<CAVariationNG.rsg>

const TInt KGranularity = 2;

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

// CCAGroupUtilsPC::CCAGroupUtilsPC

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

// might leave.

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

//

CCAGroupUtilsPC::CCAGroupUtilsPC( CCAEngine& aEngine )

        : iEngine( aEngine )

    {

    }

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

// CCAGroupUtilsPC::NewLC

// Two-phased constructor.

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

//

CCAGroupUtilsPC* CCAGroupUtilsPC::NewLC( CCAEngine& aEngine )

    {

    CCAGroupUtilsPC* temp = new( ELeave )CCAGroupUtilsPC( aEngine );

    CleanupStack::PushL( temp );

    temp->ConstructL();

    return temp;

    }

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

// CCAGroupUtilsPC::NewL

// Two-phased constructor.

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

//

CCAGroupUtilsPC* CCAGroupUtilsPC::NewL( CCAEngine& aEngine )

    {

    CCAGroupUtilsPC* self = CCAGroupUtilsPC::NewLC( aEngine );

    CleanupStack::Pop();

    return self;

    }

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

// CCAGroupUtilsPC: ConstructL

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

//

void CCAGroupUtilsPC::ConstructL(  )

    {

    iStoredGroups = CCAStorageManagerFactory::GroupListInterfaceL();

    iGroupManagerInterface = iEngine.GetGroupInterface();

    }

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

// CCAGroupUtilsPC::~CCAGroupUtilsPC

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

//

CCAGroupUtilsPC::~ CCAGroupUtilsPC(  )

    {

    }

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

// CCAGroupUtilsPC::GetChatInfoArrayLC

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

//

CCAChatInfoArray* CCAGroupUtilsPC::GetChatInfoArrayL( const TDesC& aGroupId )

    {

    // create listbox item array

    CCAChatInfoArray* itemArray = CCAChatInfoArray::NewL();

    CleanupStack::PushL( itemArray );

    //get the group

    MCAStoredGroup* group = iStoredGroups->FindGroup( aGroupId );

    if ( !group )

        {

        CleanupStack::PopAndDestroy(); //itemArray

        return NULL;// leave from here

        }

    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 );

    //Getting group properties and members

    MCAGroupOperations* grOps =

        iGroupManagerInterface->GroupOperationsL( aGroupId );

    CImpsCommonGroupProps* groupProps = NULL;

    CImpsPrivateGroupProps* privateProps = NULL;

    TInt err( grOps->GetPropertiesL( groupProps, privateProps ) );

    if ( err == KErrNone && group->IsAdmin() )

        {

        err = grOps->GetMembersL( *userList, *screenNames, *moders, *admins );

        }

    if ( err != KErrNone )

        {

        if ( err == ECSPInsufficientGroupPrivileges )

            {

            // Show general server error note, if user has

            // insufficient privileges.

            err = ECSPInternalOrNetworkError;

            }

        CleanupStack::PopAndDestroy( 4, userList );

        CleanupStack::PopAndDestroy(); //itemArray

        User::Leave( err );

        return NULL;

        }

    CHAT_DP( D_CHAT_LIT( " %d users, %d screenNames, %d moders, %d admins" ),

             userList->Count(), screenNames->Count(), moders->Count(),

             admins->Count() );

    // load participants text with correct numbers (two items in partiarray)

    CArrayFixFlat<TInt>* partiArray = new ( ELeave ) CArrayFixFlat<TInt>( KGranularity );

    CleanupStack::PushL( partiArray );

    partiArray->AppendL( group->NumParticipants()  );

    partiArray->AppendL( groupProps->MaxNbrOfUsers() );

    HBufC* partiBuf = StringLoader::LoadLC( R_CHATLIST_VIEW_INFO_NUMB_PARTI,

                                            *partiArray );

    // add items to item array

    TPtrC displayId( CCAPCUtils::DisplayId( aGroupId ) );

    itemArray->AddLabelAndTextL( R_CHATLIST_VIEW_INFO_GID, displayId );

    itemArray->AddLabelAndTextL( R_CHATLIST_VIEW_INFO_TOP,

                                 groupProps->Topic() );

    itemArray->AddLabelAndTextL( R_CHATLIST_VIEW_INFO_NUMB, *partiBuf );

    CleanupStack::PopAndDestroy( partiBuf );

    CleanupStack::PopAndDestroy( partiArray );

    // add admins

    HBufC* adminBuf = CCAPCUtils::CreateBufLC( *admins, ETrue );

    itemArray->AddLabelAndTextL( R_CHATLIST_VIEW_INFO_ADMIN, *adminBuf );

    CleanupStack::PopAndDestroy( adminBuf );

    // add banned users

    if ( group->IsAdmin() || group->IsOwnGroup() )

        {

        CHAT_DP_TXT( "displaying reject list" );

        CDesCArray* rejectList = new ( ELeave ) CDesCArrayFlat(

            KArrayGranularity );

        CleanupStack::PushL( rejectList );

        err = grOps->GetRejectListL( *rejectList );

        if ( err == KErrNone )

            {

            HBufC* banBuf = CCAPCUtils::CreateBufLC( *rejectList, ETrue );

            itemArray->AddLabelAndTextL( R_CHATLIST_VIEW_INFO_BANNED, *banBuf );

            CleanupStack::PopAndDestroy( banBuf );

            }

        CleanupStack::PopAndDestroy( rejectList );

        }

    // load the whisper text

    HBufC* whispBuf = NULL;

    if ( groupProps->IsPrivateAllowed() == EImpsPropYes )

        {

        whispBuf = CCoeEnv::Static()->

                   AllocReadResourceLC( R_CHATLIST_VIEW_INFO_WHIS_YES );

        }

    else

        {

        whispBuf = CCoeEnv::Static()->

                   AllocReadResourceLC( R_CHATLIST_VIEW_INFO_WHIS_NO );

        }

    // append to listbox

    itemArray->AddLabelAndTextL( R_CHATLIST_VIEW_INFO_WHIS, *whispBuf );

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

    // screenNames, userList,whispBuf

    CleanupStack::Pop( itemArray );

    return itemArray;

    }

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

// CCAGroupUtilsPC::GetCreatedChatRoomListL

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

//

TInt CCAGroupUtilsPC::GetCreatedChatRoomListL( CDesCArray& aTempArray, CDesCArray& aGroupIds )

    {

    TInt err = KErrNone;

    iGroupManagerInterface->PopulateCreatedGroupsL( aGroupIds );

    HBufC* itemText = HBufC::NewLC( KMaxChatGroupLenght + KMaxTabLength );

    TPtr itemTextPtr( itemText->Des() );

    TInt count( aGroupIds.MdcaCount() );

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

        {

        itemTextPtr.Append( KIconTabulator );

        itemTextPtr.Append(

            CCAStorageManagerFactory::ContactListInterfaceL()->Identification(

                aGroupIds.MdcaPoint( i ) ) );

        aTempArray.AppendL( *itemText );

        itemTextPtr.Zero();

        }

    CleanupStack::PopAndDestroy( itemText );

    return err;

    }

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

// CCAGroupUtilsPC::DeleteChatGroupFromNetworkL

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

//

TInt CCAGroupUtilsPC::DeleteChatGroupFromNetworkL( const TDesC& aGroupId, TBool aDeleteFromNetwork )

    {

    MCAStoredGroups* groups =

        CCAStorageManagerFactory::GroupListInterfaceL();

    MCAStoredGroup* group = groups->FindGroup( aGroupId );

    if ( !group )

        {

        // Because the groups that user selected are fetched from

        // network, and though they might not be in our local storage,

        // we need to create those groups to make sure that storage

        // does also network operations.

        group = groups->CreateGroupL();

        static_cast<MCAExtendedStoredGroup*>( group )->SetVisible(

            EFalse );

        static_cast<MCAExtendedStoredGroup*>( group )->SetGroupIdL(

            aGroupId );

        }

    return iGroupManagerInterface->DeleteGroupL( aGroupId, aDeleteFromNetwork );

    }

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

// CCAGroupUtilsPC::DeleteGroupL

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

//

TInt CCAGroupUtilsPC::DeleteGroupL( const TDesC& aGroupId,

                                    TBool  aDeleteFromNetwork )

    {

    return iGroupManagerInterface->DeleteGroupL( aGroupId,

                                                 aDeleteFromNetwork );

    }

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

// CCAGroupUtilsPC::SwitchToJoinedGroupL

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

//

TInt CCAGroupUtilsPC::SwitchToJoinedGroupL( const TDesC& aGroupID,

                                            TCADnlChatViewBuf& aViewDnl ,

                                            const MCAConversationMessage* aFwdMessage,

                                            TBool aInviteQuery )

    {

    if ( !iEngine.ChatInterface().ChatExistsL( KNullDesC, KNullDesC, aGroupID ) )

        {

        return R_CHATLIST_VIEW_JOIN_ERROR;

        }

    TCADnlChatView viewDnl;

    if ( aFwdMessage )

        {

        viewDnl.iIsForwarded = ETrue;

        viewDnl.iForwardedMessage = aFwdMessage;

        }

    else

        {

        viewDnl.iIsForwarded = EFalse;

        }

    viewDnl.iInviteQuery = aInviteQuery;

    viewDnl.iSwitchTab = EFalse;

    MCAStoredGroup* group = CCAStorageManagerFactory::

                            GroupListInterfaceL()->FindGroup( aGroupID );

    viewDnl.iGroupId = aGroupID.Left( viewDnl.iGroupId.MaxLength() );

    viewDnl.iGroupName =

        group->GroupName().Left( viewDnl.iGroupName.MaxLength() );

    aViewDnl = viewDnl;

    return KErrNone;

    }

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

// CCAGroupUtilsPC::GetDefaultGroupNameL

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

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

void CCAGroupUtilsPC::GetDefaultGroupNameL( TPtr& aChatGroupName,

                                            TEnumsPC::TListSelectionType aSelType )

    {

    // Construct default group name for query

    switch ( aSelType )

        {

        case TEnumsPC::ESingleListMultiSelect:

            {

            HBufC* listGroupName = StringLoader::LoadLC(

                                       RSC_CHAT_GROUP_DEFAULT_LIST,

                                       aChatGroupName

                                   );

            aChatGroupName.Copy( listGroupName->Left( KMaxChatGroupLenght ) );

            CleanupStack::PopAndDestroy( listGroupName );

            break;

            }

        default:

            {

            TInt nbrOfChats = iGroupManagerInterface->

                              NumberOfCreatedGroupsDuringSession();

            MCAStoredContacts* contactlist =

                CCAStorageManagerFactory::ContactListInterfaceL();

            TPtrC ownId = contactlist->OwnStatus().Identification();

            HBufC* groupName = StringLoader::LoadLC( RSC_CHAT_GROUP_DEFAULT,

                                                     ownId,

                                                     nbrOfChats + 1 );

            aChatGroupName.Copy( groupName->Left( KMaxChatGroupLenght ) );

            // convert numbers to local language.

            // Exclude indentification part of text.

            TInt pos = aChatGroupName.Find( ownId );

            if ( pos != KErrNotFound )

                {

                TInt end = pos + ownId.Length();

                // after id part

                if ( end < aChatGroupName.Length() )

                    {

                    TPtr nonIdPart = aChatGroupName.MidTPtr( end );

                    AknTextUtils::DisplayTextLanguageSpecificNumberConversion(

                        nonIdPart );

                    }

                // before id part

                if ( pos > 0 )

                    {

                    TPtr nonIdPart = aChatGroupName.LeftTPtr( pos );

                    AknTextUtils::DisplayTextLanguageSpecificNumberConversion(

                        nonIdPart );

                    }

                }

            CleanupStack::PopAndDestroy( groupName );

            break;

            }

        }

    }

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

// CCAGroupUtilsPC::ScreenNameQueryL

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

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

void CCAGroupUtilsPC::ScreenNameQueryL( TDes& aScreenName )

    {

    TInt askScreenName = IMUtils::IntResourceValueL(

                             RSC_CHAT_VARIATION_SCREENNAME_QUERY );

    TInt screenNameStrategy = IMUtils::IntResourceValueL(

                                  RSC_CHAT_VARIATION_SCREENNAME_DEFAULT );

    TInt snSettings = IMUtils::IntResourceValueL(

                          RSC_CHAT_VARIATION_SCREENNAME_SETTING );

    TBool isSnSet = iEngine.GetInternalSettingsInterface()->Value(

                        MCASettings::EDefaultScreenNameInUse );

    TInt aliasEnabled = IMUtils::IntResourceValueL(

                            RSC_CHAT_VARIATION_HAVE_ALIAS );

    TInt snMaxLen = aScreenName.MaxLength();

    TInt copyLen = snMaxLen < KScreenNameQueryMaxLength ?

                   snMaxLen : KScreenNameQueryMaxLength;

    switch ( screenNameStrategy )

        {

        case 0 :

            {

            // use empty screen name

            aScreenName.Copy( KNullDesC() );

            break;

            }

        case 1 :

            {

            // userid, overwrite screen name buffer with userid

            HBufC* ownWVIDbuf = iEngine.GetInternalSettingsInterface()->

                                ValueL( MCASettings::EOwnWVUserID );

            CleanupStack::PushL( ownWVIDbuf );

            // make sure it can fit

            TPtrC displayId( CCAPCUtils::DisplayId( *ownWVIDbuf ) );

            aScreenName.Copy( displayId.Left( copyLen ) );

            CleanupStack::PopAndDestroy( ownWVIDbuf );

            break;

            }

        case 2 :

            {

            // screen name, default behaviour

            if ( snSettings && isSnSet )

                {

                HBufC* sn = iEngine.GetInternalSettingsInterface()->ValueL(

                                MCASettings::EDefaultScreenName );

                if ( sn->Length() > 0 )

                    {

                    aScreenName.Copy( sn->Left( copyLen ) );

                    }

                delete sn;

                }

            break;

            }

        case 3 :

            {

            // alias

            if ( aliasEnabled )

                {

                HBufC* alias = iEngine.GetInternalSettingsInterface()->OwnAliasL();

                if ( alias && alias->Length() > 0 )

                    {

                    aScreenName.Copy( alias->Left( copyLen ) );

                    }

                else

                    {

                    // If alias is not defined, we need to query screenname.

                    askScreenName = ETrue;

                    }

                delete alias;

                }

            break;

            }

        default :

            {

            break;

            }

        }

    }

// pcside_complete

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

// CCAGroupUtilsPC::MoveOwnIdToFirstL

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

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

//

void CCAGroupUtilsPC::MoveOwnIdToFirstL( CDesCArray& aList )

    {

    // find the own wvid from list and move it to the beginning

    HBufC* ownWVIDbuf = iEngine.GetInternalSettingsInterface()->

                        ValueL( MCASettings::EOwnWVUserID );

    CleanupStack::PushL( ownWVIDbuf );

    TInt listLen = aList.Count();

    // must traverse list backwards

    for ( TInt i = listLen - 1; i >= 0; i-- )