/*

* 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:  Utility class for presence functions

*

*/

// INCLUDE FILES

#include "CAPresenceDefinitions.h"

#include "CAPresenceUtils.h"

#include "ChatDebugPrint.h"

#include "CCAStorageManagerFactory.h"

#include "MCAStoredContact.h"

#include "MCAStoredContacts.h"

#include "MCAWatcherObserver.h"

#include "CCAPresenceError.h"

#include "CCAPresenceErrors.h"

#include "ImpsCSPAllErrors.h"

#include "CAPresenceConst.h"

#include "MCAContactList.h"

#include "TDecodeAttrParams.h"

#include "SServerPrefers.h"

#include "MCAPresenceUpdater.h"

#include "impsbuilddefinitions.h"

#include "WVUIPresenceVariationNG.hrh"

#include <WVUIPresenceVariationNG.rsg>

#include <PEngWVPresenceAttributes2.h>

#include <MPEngPresenceAttrModel2.h>

#include <MPEngContactList2.h>

#include <MPEngTransactionStatus2.h>

#include <PEngWVPresenceErrors2.h>

#include <ImpsErrors.h>

#include <PEngPresenceEngineErrors2.h>

#include <MPEngContactItem.h>

#include <MPEngContactListProperties.h>

#include <barsread.h> // RResourceReader

#include <eikenv.h>

// "test character identity and accents, ignore case"

const TInt KCollationLevel = 1;

#ifndef IMPS_FETCH_CONTACT_BACKGROUND

const TInt KMaxIdAtTheTime = 2;

#else

const TInt KMaxIdAtTheTime = 20;

#endif //IMPS_FETCH_CONTACT_BACKGROUND

_LIT( KPanicAttribute, "WVUIPresenceVariation attribute" );

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

// CAPresenceUtils::DecodeOnlineState

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

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

//

MCAPresence::TPresenceStatus CAPresenceUtils::DecodeOnlineState(

    const RPointerArray<CCAState>& aStates,

    const RPointerArray<MPEngPresenceAttrModel2>& aAttributes )

    {

    MCAPresence::TPresenceStatus status( MCAPresence::EUnknown );

    TInt stateCount( aStates.Count() );

    TBool stateFound( EFalse );

    for ( TInt stateIndex( 0 ); stateIndex < stateCount && !stateFound; ++stateIndex )

        {

        CCAState* state = aStates[stateIndex];

        TInt stateAttrCount( state->iAttributes.Count() );

        if ( stateAttrCount == 0 )

            {

            // no attributes => default state

            status = MCAPresence::TPresenceStatus( state->iStateId );

            }

        else

            {

            // we have a match if:

            // all attributes defined in state can be found from current

            // set of attributes with same values as in state.

            stateFound = ETrue;

            for ( TInt stateAttrIndex( 0 ); stateAttrIndex < stateAttrCount  &&

                  stateFound; ++stateAttrIndex )

                {

                TCAAttribute& stateAttr = state->iAttributes[stateAttrIndex];

                const MPEngPresenceAttrModel2* attr =

                    FindAttr( stateAttr.iAttribute, aAttributes );

                if ( attr )

                    {

                    // attribute found

                    if ( attr->DataInt( stateAttr.iField, stateAttr.iGroup )

                         != stateAttr.iData ||

                         attr->Qualifier()

                         != stateAttr.iQualifier )

                        {

                        // but different value or qualifier => doesn't match

                        stateFound = EFalse;

                        }

                    }

                else

                    {

                    // not found at all => doesn't match

                    stateFound = EFalse;

                    }

                }

            if ( stateFound )

                {

                status = MCAPresence::TPresenceStatus( state->iStateId );

                }

            }

        }

    CHAT_DP_TXT( "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" );

    return status;

    }

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

// CAPresenceUtils::PopulateAttributes

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

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

//

void CAPresenceUtils::PopulateAttributesL( const MPEngPresenceAttrModel2& aModel,

                                           RPointerArray<MPEngPresenceAttrModel2>& aArray,

                                           TStorageManagerGlobals::TClientType& aClientType,

                                           TPtrC& aAlias,

                                           TPtrC& aStatusText )

    {

    switch ( aModel.Type() )

        {

        case KUidPrAttrClientInfo:

            {

            aClientType = TStorageManagerGlobals::EUnknownClient;

            if ( aModel.Qualifier() )

                {

                switch ( aModel.DataInt( EPEngCliInfDeviceType ) )

                    {

                    case EPEngCliDevTypeMobilePhone:

                        {

                        aClientType = TStorageManagerGlobals::EMobile;

                        break;

                        }

                    case EPEngCliDevTypeComputer:

                        {

                        aClientType = TStorageManagerGlobals::EPC;

                        break;

                        }

                    default:

                        {

                        // nothing to do here

                        }

                    }

                }

            break;

            }

        case KUidPrAttrAlias:

            {

            if ( aAlias.Ptr() )

                {

                // have valid descriptor to where this points,

                // otherwise it's unused by the IM Open Conversation

                // routines

                aAlias.Set( aModel.DataDesC16( EPEngAlias ) );

                }

            break;

            }

        case KUidPrAttrStatusText:

            {

            if ( ! aStatusText.Ptr() )

                {

                // have valid descriptor to where this points,

                // otherwise it's unused by the IM Open Conversation

                // routines

                aStatusText.Set( aModel.DataDesC16( EPEngStatusText ) );

                }

            break;

            }

        default:

            {

            aArray.AppendL( &aModel );

            break;

            }

        }

    }

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

// CAPresenceUtils::GenerateFriendsArrayLC

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

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

//

CPtrCArray* CAPresenceUtils::GenerateFriendsArrayLC(

    MCAStoredContacts* aContactStorage )

    {

    TInt granularity( aContactStorage->ContactCount() );

    if ( granularity == 0 )

        {

        granularity = 1;

        }

    CPtrCArray* contactsArray =

        new ( ELeave ) CPtrCArray( granularity );

    CleanupStack::PushL( contactsArray );

    TInt listCount( aContactStorage->ListCount() );

    TKeyArrayFix cmpKey( 0, ECmpCollated );

    for ( TInt a( 0 ); a < listCount; ++a )

        {

        MCAContactList& contactList = aContactStorage->ListAt( a );

        TInt contactCount( contactList.Count() );

        for ( TInt b( 0 ); b < contactCount; ++b )

            {

            TPtrC userId( contactList[ b ].UserId() );

            TInt pos( KErrNotFound );

            if ( userId.Length() > 0 )

                {

                // user id exists

                if ( contactsArray->FindIsq( userId, cmpKey, pos ) != 0 )

                    {

                    // user id not found already from the list, so let's add it

                    contactsArray->InsertIsqL( userId, cmpKey );

                    }

                }

            }

        }

    return contactsArray;

    }

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

// CAPresenceUtils::PushModelArrayL

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

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

//

void CAPresenceUtils::PushModelArrayL(

    RPointerArray<MPEngPresenceAttrModel2>& aArray, TBool aOwnsItems )

    {

    if ( aOwnsItems )

        {

        CleanupStack::PushL( TCleanupItem( DestroyCloseModelArray, &aArray ) );

        }

    else

        {

        CleanupStack::PushL( TCleanupItem( CloseModelArray, &aArray ) );

        }

    }

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

// CAPresenceUtils::DecodeAttrModelsL

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

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

//

TBool CAPresenceUtils::DecodeAttrModelsL( struct TDecodeAttrParams& aParams )

    {

    CHAT_DP_TXT( "CAPresenceUtils::DecodeAttrModelsL  Enter" );

    // unpack the structure for easier access

    RPointerArray<CCAState>* states = aParams.iPresenceStates;

    RPointerArray< MPEngPresenceAttrModel2 >& array = aParams.iArray;

    MCAStoredContacts* contactStorage = aParams.iContactStorage;

    MCAWatcherObserver* watcherObserver = aParams.iWatcherObserver;

    CDesCArray* stateOnline = aParams.iStateOnline;

    CDesCArray* stateOffline = aParams.iStateOffline;

    CDesCArray* stateUnknown = aParams.iStateUnknown;

    TInt& entryIndex = aParams.iEntryIndex;

    TBool done( EFalse ); // flag for loop termination

    TBool updateUserData( EFalse );

    MPEngPresenceAttrModel2* model = NULL;

    RPointerArray<MPEngPresenceAttrModel2> attributes;

    CAPresenceUtils::PushModelArrayL( attributes, EFalse );

    // alias support preparations

    TPtrC aliasPtr( NULL, 0 );

    HBufC* dummy = NULL;

    if ( aParams.iServerPrefers.iAliasUsed )

        {

        // have alias support

        // alias ptr must point to non-NULL

        dummy = HBufC::NewL( 1 );

        CleanupStack::PushL( dummy );

        aliasPtr.Set( dummy->Des() );

        }

    else

        {

        // no alias support

        aliasPtr.Set( NULL, 0 );

        }

    TPtrC statusText( NULL, 0 );

    TStorageManagerGlobals::TPresenceStatus newPresenceStatus =

        TStorageManagerGlobals::EUnknown;

    TStorageManagerGlobals::TPresenceStatus oldPresenceStatus =

        TStorageManagerGlobals::EUnknown;

    TStorageManagerGlobals::TClientType clientType =

        TStorageManagerGlobals::EUnknownClient;

    TInt attrCount( array.Count() );

    const TDesC* lastID = NULL;

    CHAT_DP( D_CHAT_LIT( "DecodeAttrModelsL for %d models" ), attrCount );

    // Loop through all attributes received

    TInt idCount( 0 );

    do

        {

        updateUserData = EFalse;

        if ( entryIndex < attrCount )

            {

            model = array[entryIndex];

            // Create initial userID or

            // Check if all attributes concerning this user has been processed

            if ( !lastID )

                {

                lastID = &model->PresenceID();

                }

            else if ( model->PresenceID() != *lastID )

                {

                ++idCount;

                updateUserData = ETrue;

                }

            }

        else

            {

            if ( attrCount > 0 )

                {

                updateUserData = ETrue;

                }

            done = ETrue;

            }

        // If all attributes concerning certain user have been collected,

        // then we can update local presence information concerning that user

        if ( updateUserData )

            {

            newPresenceStatus = MapPresenceStateId(

                                    DecodeOnlineState( *states, attributes ) );

            CAPresenceUtils::FillArraysL( *lastID, newPresenceStatus,

                                          stateOnline, stateOffline,

                                          stateUnknown );

            if ( contactStorage )

                {

                MCAStoredContact* updatedContact = contactStorage->UpdatePresenceL(

                                                       *lastID, newPresenceStatus,

                                                       clientType, aliasPtr,

                                                       statusText,

                                                       oldPresenceStatus );

                if ( updatedContact )

                    {

                    if ( updatedContact->IsWatched()

                         && watcherObserver

                         && ( newPresenceStatus != TStorageManagerGlobals::EUnknown )

                         && !( newPresenceStatus == TStorageManagerGlobals::EOffline

                               && oldPresenceStatus == TStorageManagerGlobals::EUnknown )

                       )

                        {

                        watcherObserver->HandleWatcherEvent( updatedContact );

                        }

                    }

                }

            // reset attributes

            attributes.Reset();

            clientType = TStorageManagerGlobals::EUnknownClient;

            if ( aParams.iServerPrefers.iAliasUsed )

                {

                // have alias support

                // alias ptr must point to non-NULL

                aliasPtr.Set( dummy->Des() );

                }

            statusText.Set( NULL, 0 );

            }

        if ( !done && idCount < KMaxIdAtTheTime )

            {

            lastID = &model->PresenceID();

            CAPresenceUtils::PopulateAttributesL( *model,

                                                  attributes,

                                                  clientType,

                                                  aliasPtr,

                                                  statusText );

            }

        ++entryIndex;

        } while ( !done && idCount < KMaxIdAtTheTime );

    --entryIndex;

    if ( aParams.iServerPrefers.iAliasUsed )

        {

        CleanupStack::PopAndDestroy( dummy );

        }

    CleanupStack::PopAndDestroy(); // attributes.Close()

    CHAT_DP( D_CHAT_LIT( "CAPresenceUtils::DecodeAttrModelsL  Done-:%d" ), done );

    return !done;

    }

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

// CAPresenceUtils::HandleListErrorsL

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

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

//

void CAPresenceUtils::HandleListErrorsL( TInt aError )

    {

    CHAT_DP( D_CHAT_LIT( "CCAPEngListManager::HandleListErrorsL checking \

	                      error %d" ), aError );

    if ( aError != KErrNone && aError != KErrNotFound

         && aError != KErrAlreadyExists )

        {

        CHAT_DP_TXT( "Error can not be ignored, leaving..." );

        User::Leave( aError );

        }

    }

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

// CAPresenceUtils::CompareAttrModelArray

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

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

//

TInt CAPresenceUtils::CompareAttrModelArray(

    const MPEngPresenceAttrModel2& aFirst,

    const MPEngPresenceAttrModel2& aSecond )

    {

    return aFirst.PresenceID().CompareC( aSecond.PresenceID(), KCollationLevel,

                                         NULL );

    }

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

// CAPresenceUtils::CloseModelArray

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

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

//

void CAPresenceUtils::CloseModelArray( TAny* aObject )

    {

    reinterpret_cast<RPointerArray<MPEngPresenceAttrModel2>*>( aObject )->

    Close();

    }

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

// CAPresenceUtils::DestroyCloseModelArray

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

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

//

void CAPresenceUtils::DestroyCloseModelArray( TAny* aObject )

    {

    reinterpret_cast<RPointerArray<MPEngPresenceAttrModel2>*>( aObject )->

    ResetAndDestroy();

    }

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

// CAPresenceUtils::FillArraysL

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

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

//

void CAPresenceUtils::FillArraysL(

    const TDesC& aUserId,

    TStorageManagerGlobals::TPresenceStatus aOnlineStatus,

    CDesCArray *aStateOnline,

    CDesCArray *aStateOffline,

    CDesCArray *aStateUnknown )

    {

    if ( aUserId == KNullDesC )

        {

        // if userID == KNullDesC then this is probably our own presence notify

        // no need to do anything here

        return;

        }

    switch ( aOnlineStatus )

        {

        case TStorageManagerGlobals::EOnline:

        case TStorageManagerGlobals::EAway:

        case TStorageManagerGlobals::EBusy: // flow through

            {

            if ( aStateOnline )

                {

                aStateOnline->AppendL( aUserId );

                }

            break;

            }

        case TStorageManagerGlobals::EOffline:

            {

            if ( aStateOffline )

                {

                aStateOffline->AppendL( aUserId );

                }

            break;

            }

        case TStorageManagerGlobals::EUnknown:

            {

            if ( aStateUnknown )

                {

                aStateUnknown->AppendL( aUserId );

                }

            break;

            }

        default:

            {

            // Unknown state, ignore

            break;

            }

        }

    }

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

// CAPresenceUtils::HandleTransactionStatusL

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

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

//

void CAPresenceUtils::HandleTransactionStatusL( MPEngTransactionStatus2&