/*

* 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:  Network operations for chat group handling.

 *

*/

// INCLUDE FILES

#include "ChatDebugPrint.h"

#include "CCAGroupManager.h"

#include "CCAStorageManagerFactory.h"

#include "MCASettings.h"

#include "MCASearchData.h"

#include "MCASearchInterface.h"

#include "MCAStoredGroups.h"

#include "MCAStoredGroup.h"

#include "MCAExtendedStoredGroup.h"

#include "MCAGroupOperations.h"

#include "CCAGroupWrapper.h"

#include "PrivateEngineDefinitions.h"

#include "TStorageManagerGlobals.h"

#include "CCARequest.h"

#include "CCARequestMapper.h"

#include "MCAChatInterface.h"

#include "MCAMessagesWriteInterface.h"

#include "MCAMessageUtils.h"

#include "MCAMessageCreator.h"

#include "ImpsCSPAllErrors.h"

#include "MCAImpsFactory.h"

#include "CAUtils.h"

#include "camessageutil.h"

#include <e32keys.h>

#include <ImpsFundamental.h>

#include <ImpsGroupProps.h>

// for resources

#include <caengineNG.rsg>

#include <stringloader.h>

// CONSTANTS

const TInt KCCAGMGroupWrappersGranularity = 5;

const TInt KSearchPairsSmallGranularity = 1;

const TInt KMaxUserSearchLimit = 100;

// indexes to additional data array inside request

const TInt KReqCreateIndexGroupId    = 0;

const TInt KReqCreateIndexScreenName = 2;

const TInt KReqCreateIndexWelcomeMsg = 3;

const TInt KReqCreateIndexGroupTopic = 4;

const TInt KReqJoinIndexGroupId    = 0;

const TInt KReqJoinIndexScreenName = 1;

// how many times should we try to generate unique group id

const TInt KMaxGroupIds = 100;

// maximum groups in search result. If search results

// exceeds this then "too many search results" is shown

const TInt KMaxGroupSearchLimit = 50;

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

// Symbian OS default constructor can leave.

void CCAGroupManager::ConstructL()

    {

    iStoredGroups = CCAStorageManagerFactory::GroupListInterfaceL();

    }

// Two-phased constructor.

CCAGroupManager* CCAGroupManager::NewL(

    MCASearchInterface& aSearchAPI,

    MCASettings& aSettingsAPI,

    CCARequestMapper& aRequestMapper,

    MCAImpsFactory* aIMPSFactory,

    MCAChatInterface& aChatInterface,

    MCAMessageUtils& aMessageUtils )

    {

    CCAGroupManager* self = new ( ELeave ) CCAGroupManager( aSearchAPI,

                                                            aSettingsAPI, aRequestMapper, aIMPSFactory,

                                                            aChatInterface, aMessageUtils );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CCAGroupManager::~CCAGroupManager()

    {

    iGroupWrappers.ResetAndDestroy();

    delete iProperties;

    delete iPrivProperties;

    }

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

// might leave.

//

CCAGroupManager::CCAGroupManager(

    MCASearchInterface& aSearchAPI,

    MCASettings& aSettingsAPI,

    CCARequestMapper& aRequestMapper,

    MCAImpsFactory* aIMPSFactory,

    MCAChatInterface& aChatInterface,

    MCAMessageUtils& aMessageUtils   )

        : iRequestMapper( aRequestMapper ),

        iSettingsAPI( aSettingsAPI ),

        iSearchAPI( aSearchAPI ),

        iImpsFactory( aIMPSFactory ),

        iChatInterface( aChatInterface ),

        iMessageUtils( aMessageUtils ),

        iGroupWrappers( KCCAGMGroupWrappersGranularity )

    {

    }

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

// CCAGroupManager::PopulateCreatedGroupsL

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

//

TInt CCAGroupManager::PopulateCreatedGroupsL( CDesCArray& aGroupList ) const

    {

    CHAT_DP_FUNC_ENTER( "PopulateCreatedGroupsL" );

    // Reset the given array to be sure that it will be valid

    aGroupList.Reset();

    HBufC* loggedUserId = iSettingsAPI.ValueL( MCASettings::EOwnWVUserID );

    CleanupStack::PushL( loggedUserId );

    CSearchPairs* pairs =

        new ( ELeave ) CSearchPairs( KSearchPairsSmallGranularity );

    CleanupStack::PushL( pairs );

    CImpsSearchRequest* request = CImpsSearchRequest::NewL();

    CleanupStack::PushL( request );

    request->SetRequestL( EImpsGroupUserIDOwner, *loggedUserId );

    pairs->AppendL( request );

    // If there is error in search, return so we don't send stop error request

    TInt searchError( KErrNone );

    searchError = iSearchAPI.StartSearchL( *pairs, KMaxUserSearchLimit, NULL );

    if ( searchError != KErrNone )

        {

        CHAT_DP( D_CHAT_LIT( "CCAGroupManager::PopulateCreatedGroupsL - error \

                              from StartSearchL %d" ), searchError );

        // request, pairs, loggedUserId

        CleanupStack::PopAndDestroy( 3, loggedUserId );

        return searchError;

        }

    TInt resultCount( iSearchAPI.SearchDataInterface()->SearchDataCount() );

    // just add all found groups to the group list

    for ( TInt counter( 0 ); counter < resultCount; counter++ )

        {

        TPtrC pGroupId(

            iSearchAPI.SearchDataInterface()->SearchData( counter ) );

        aGroupList.AppendL( pGroupId );

        }

    CHAT_DP( D_CHAT_LIT( "CCAGroupManager::PopulateCreatedGroupsL - found %d \

                          groups from joined user" ), aGroupList.Count() );

    CleanupStack::PopAndDestroy( 3, loggedUserId );

    CHAT_DP_FUNC_DONE( "PopulateCreatedGroupsL" );

    return KErrNone;

    }

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

// CCAGroupManager::JoinedGroups

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

//

TInt CCAGroupManager::JoinedGroups()

    {

    return iNumJoinedGroups;

    }

// we just wrap the Handle*L routines by passing them

// on to the correct group wrapper

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

// CCAGroupManager::HandleErrorL

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

//

void CCAGroupManager::HandleErrorL(

    TInt aStatus,

    TInt aOpId,

    const TDesC* /* aDescription */,

    const CImpsDetailed* /* aDetailedRes */,

    TImpsCspIdentifier& /*aCspId*/ )

    {

    CHAT_DP_FUNC_ENTER( "HandleErrorL" );

    CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleErrorL - opid=%d, status=%d" ),

             aOpId, aStatus );

    CHAT_DP_FUNC_DONE( "HandleErrorL" );

    }

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

// CCAGroupManager::HandleCompleteL()

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

//

void CCAGroupManager::HandleCompleteL(

    TInt aOpId,

    TImpsCspIdentifier& aCspId )

    {

    CHAT_DP_FUNC_ENTER( "HandleCompleteL" );

    CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleCompleteL - opid=%d" ), aOpId );

    CCAGroupWrapper* wrapper = FindGroupWrapper( aOpId );

    if ( ! wrapper )

        {

        // no such wrapper

        CHAT_DP_FUNC_DP( "HandleCompleteL", "No wrapper, leaving" );

        User::Leave( KErrNotFound );

        }

    CCARequest* request = wrapper->Request();

    __ASSERT_DEBUG( request, User::Panic( KCAEnginePanicCategory,

                                          KErrNotFound ) );

    if ( !request )

        {

        User::Leave( KErrNotFound );

        }

    const MDesCArray* dataArray = request->AdditionalData();

    switch ( request->RequestType() )

        {

        case ECreateAndJoinGroup :

            {

            __ASSERT_DEBUG( dataArray, User::Panic( KCAEnginePanicCategory,

                                                    KErrNotFound ) );

            if ( !dataArray )

                {

                // can't use User::LeaveIfNull for const pointers

                User::Leave( KErrGeneral );

                }

            CHAT_DP_FUNC_DP( "HandleCompleteL", "Creating chat data for group" );

            MCAMessagesWriteInterface& groupChat =

                iChatInterface.MessageWriteInterfaceL( KNullDesC, KNullDesC,

                                                       dataArray->MdcaPoint( KReqCreateIndexGroupId ),

                                                       MCAMessagesReadInterface::EGroupContainer );

            groupChat.SetScreenNameL( dataArray->MdcaPoint(

                                          KReqCreateIndexScreenName ) );

            // Write welcome message to chat

            TPtrC welcome = dataArray->MdcaPoint( KReqCreateIndexWelcomeMsg );

            TPtrC topic = dataArray->MdcaPoint( KReqCreateIndexGroupTopic );

            CHAT_DP_FUNC_DP( "HandleCompleteL", "Showing welcome message" );

            MCAStoredGroup& group = wrapper->Group();

            TPtrC groupIdentifier =

                group.GroupName().Length() > 0 ? group.GroupName() :

                CAUtils::DisplayId( group.GroupId() );

            WriteWelcomeMessageL( welcome, groupIdentifier, topic, groupChat );

            // note, it suffices to increase the number of created groups

            // when CreateGroupL is called

            break;

            }

        default:

            {

            break;

            }

        }

    wrapper->HandleCompleteL( aOpId, aCspId );

    CHAT_DP_FUNC_DONE( "HandleCompleteL" );

    }

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

// CCAGroupManager::HandleJoinL()

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

//

void CCAGroupManager::HandleJoinL(

    TInt aOpId,

    const MDesCArray& aUserList,

    const MDesCArray& aScreenNames,

    const TDesC& aWelcomeText,

    TImpsCspIdentifier& aCspId )

    {

    CHAT_DP_FUNC_ENTER( "HandleJoinL" );

    CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleJoinL - opid=%d" ), aOpId );

    CCAGroupWrapper* wrapper = FindGroupWrapper( aOpId );

    if ( ! wrapper )

        {

        // no wrapper

        CHAT_DP_FUNC_DP( "HandleJoinL", "No wrapper, leaving" );

        User::Leave( KErrNotFound );

        }

    CCARequest* request = wrapper->Request();

    __ASSERT_DEBUG( request, User::Panic( KCAEnginePanicCategory,

                                          KErrNotFound ) );

    if ( !request )

        {

        User::Leave( KErrNotFound );

        }

    const MDesCArray* dataArray = request->AdditionalData();

    __ASSERT_DEBUG( dataArray, User::Panic( KCAEnginePanicCategory,

                                            KErrNotFound ) );

    if ( !dataArray )

        {

        // can't use User::LeaveIfError for const pointers

        User::Leave( KErrGeneral );

        }

    CHAT_DP_FUNC_DP( "HandleJoinL", "Creating chat data for group" );

    MCAMessagesWriteInterface& groupChat =

        iChatInterface.MessageWriteInterfaceL( KNullDesC, KNullDesC,

                                               dataArray->MdcaPoint( KReqJoinIndexGroupId ),

                                               MCAMessagesReadInterface::EGroupContainer );

    groupChat.SetScreenNameL( dataArray->MdcaPoint( KReqJoinIndexScreenName ) );

    CImpsCommonGroupProps* commonProps = NULL;

    CImpsPrivateGroupProps* privProps = NULL;

    // ownership is preserved in wrapper

    wrapper->LocalProperties( commonProps, privProps );

    TPtrC topic( KNullDesC );

    if ( commonProps )

        {

        topic.Set( commonProps->Topic() );

        }

    // Show welcome message

    MCAStoredGroup& group = wrapper->Group();

    TPtrC groupIdentifier =

        group.GroupName().Length() > 0 ? group.GroupName() :

        CAUtils::DisplayId( group.GroupId() );

    TRAPD( err, WriteWelcomeMessageL( aWelcomeText, groupIdentifier, topic, groupChat ) );

    if ( err == KErrNoMemory )

        {

        // Handle no memory error here

        request->SetErrorCode( err );

        request->StopWaitIfNeeded();

        return;

        }

    else

        {

        User::LeaveIfError( err );

        }

    // Topic was shown in WriteWelcomeMessageL

    if ( topic.Length() > 0 )

        {

        wrapper->SetTopicShown( ETrue );

        }

    // make sure it's marked as joined in the UI

    MCAExtendedStoredGroup& grp =

        static_cast<MCAExtendedStoredGroup&>( wrapper->Group() );

    if ( !grp.IsJoined() )

        {

        grp.SetJoined( ETrue );

        iNumJoinedGroups++;

        }

    CHAT_DP_FUNC_DP( "HandleJoinL", "Passing on to wrapper" );

    wrapper->HandleJoinL( aOpId, aUserList, aScreenNames,

                          aWelcomeText, aCspId );

    // show the joined-messages

    TInt numNames = aScreenNames.MdcaCount();

    for ( TInt index = 0; index < numNames; index++ )

        {

        HBufC* newUser = aScreenNames.MdcaPoint( index ).AllocLC();

        HBufC* finalNewUserText =

            StringLoader::LoadLC( R_SYSTEM_MESSAGE_JOIN,

                                  *newUser );

        CHAT_DP_FUNC_DP( "HandleJoinL", "Initiating new users message" );

        MCAMessage* newUserMsg =

            iMessageUtils.MessageCreator().CreateSystemMessageL(

                MCAMessage::ESystemMessageNewUsers,

                *finalNewUserText );

        // Append message

        TRAPD( err, CAMessageUtil::AppendMessageWithDateStampL(

                   *newUserMsg,

                   groupChat,

                   iMessageUtils.MessageCreator() ) );

        if ( err == KErrNoMemory )

            {

            // Handle no memory error here

            CleanupStack::PopAndDestroy( 2, newUser ); // finalNewUserText, newUser

            request->SetErrorCode( err );

            request->StopWaitIfNeeded();

            return;

            }

        else

            {

            User::LeaveIfError( err );

            }

        CleanupStack::PopAndDestroy( 2, newUser ); // finalNewUserText, newUser

        }

    CHAT_DP_FUNC_DONE( "HandleJoinL" );

    }

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

// CCAGroupManager::HandleGroupMembersL()

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

//

void CCAGroupManager::HandleGroupMembersL(

    TInt aOpId,

    const MDesCArray& aUserList,

    const MDesCArray& aScreenNames,

    const MDesCArray& aModers,

    const MDesCArray& aAdmins,

    TImpsCspIdentifier& aCspId )

    {

    CHAT_DP_FUNC_ENTER( "HandleGroupMembersL" );

    CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleGroupMembersL - opid=%d" ),

             aOpId );

    CCAGroupWrapper* wrapper = FindGroupWrapper( aOpId );

    if ( ! wrapper )

        {

        CHAT_DP_FUNC_DP( "HandleGroupMembersL", "No wrapper, leaving" );

        User::Leave( KErrNotFound );

        }

    CHAT_DP_FUNC_DP( "HandleGroupMembersL", "Passing on to wrapper" );

    wrapper->HandleGroupMembersL( aOpId, aUserList, aScreenNames, aModers,

                                  aAdmins, aCspId );

    CHAT_DP_FUNC_DONE( "HandleGroupMembersL" );

    }

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

// CCAGroupManager::HandleGroupPropertiesL()

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

//

void CCAGroupManager::HandleGroupPropertiesL(

    TInt aOpId,

    const TDesC& aGroupId,

    const CImpsCommonGroupProps& aGroupProps,

    const CImpsPrivateGroupProps& aOwnProps,

    TImpsCspIdentifier& aCspId )

    {

    CHAT_DP_FUNC_ENTER( "HandleGroupPropertiesL" );

    CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleGroupPropertiesL - opid=%d" ),

             aOpId );

    CCAGroupWrapper* wrapper = NULL;

    TPtrC groupId( aGroupId );

    if ( aOpId != 0 )

        {

        // aGroupId is empty

        wrapper = FindGroupWrapper( aOpId );

        if ( !wrapper )

            {

            CHAT_DP_FUNC_DP( "HandleGroupPropertiesL", "No wrapper, leaving" );

            User::Leave( KErrNotFound );

            }

        groupId.Set( wrapper->Group().GroupId() );

        }

    else

        {

        // aGroupId is valid

        wrapper = FindGroupWrapper( aGroupId );

        }

    if ( ! wrapper )

        {

        CHAT_DP_FUNC_DP( "HandleGroupPropertiesL", "No wrapper, leaving" );

        User::Leave( KErrNotFound );

        }

    CImpsCommonGroupProps* common = NULL;

    CImpsPrivateGroupProps* priv = NULL;

    // does the wrapper have the properties already?

    wrapper->LocalProperties( common, priv );

    if ( ( !common ) && ( !priv ) )

        {

        CHAT_DP_FUNC_DP( "HandleGroupPropertiesL", "No existing properties" );

        // no existing properties, so create new ones

        common = CImpsCommonGroupProps::NewL();

        CleanupStack::PushL( common );

        priv = CImpsPrivateGroupProps::NewL();

        CleanupStack::Pop( common );

        CHAT_DP_FUNC_DP( "HandleGroupPropertiesL", "Created new properties" );