/*

* 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:  Various tools for List Library

*

*/

//  INCLUDES

#include "PEngListLibTools.h"

#include "PEngContactIdsTools.h"

#include "CPEngContactListModBase.h"

#include "CPEngContactListModItemContainer.h"

#include "CPEngContactListModChangeMonitor.h"

#include "CPEngContactListSettings.h"

#include "MPEngContactListTransactionManager.h"

#include "CPEngTransactionStatus.h"

#include "PEngXMLTags.h"

#include "MPEngXMLParser.h"

#include "MPEngXMLSerializer.h"

#include "PEngAttrLibFactory.h"

#include "MPEngPresenceAttrManager.h"

#include "MPEngPresenceAttrTransactionEnv.h"

#include "PEngWVPresenceErrors2.h"

#include "PresenceDebugPrint.h"

// ============================= LOCAL FUNCTIONS ===============================

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

// DoIsContactUpdated()

//

// Checks if:

// - the contact has been updated or is new

// - or its Nick name was updated

// - or contact was added to the contact list

// - or server altered contact id, so its length changed

//

// @param aContact Contact item container

// @param aNewContactId Contact Id as server returned it

// @param aNewNickName New nick name returned by server

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

//

inline TBool DoIsContactUpdated( CPEngContactListModItemContainer& aContact,

                                 const TDesC& aNewContactId,

                                 HBufC* aNewNickName )

    {

    const HBufC* currentNick = aContact.CurrentNick();

    TBool newValid( aNewNickName && aNewNickName->Length() );

    TBool curentValid( currentNick && currentNick->Length() );

    if (

        ( !aContact.RefActive( CPEngContactListModItemContainer::ENetworkRef ) )

        ||

        ( aNewContactId.Length() != aContact.Id().Length() )

        ||

        (

            ( newValid

              ||

              curentValid

            )

            &&

            ( !newValid

              ||

              !curentValid

              ||

              ( KErrNone != aNewNickName->Compare( *currentNick ) )

            )

        )

    )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// DoInsertContactLX()

// Inserts contact item to array of parsed contacts

// aContactId and aNickName has to be pushed on the top of the clean up stack.

// Order of those two items on clean up stack does not matter, as far as they

// are on top.

// Ownership of the aContactId and aNickName are tranfered to the function.

// Function returns EFalse if contact was existing on server before

// and ETrue if contact was just created on the server

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

//

TBool DoInsertContactLX( RPointerArray<CPEngContactListModItemContainer>& aParsedContacts,

                         RPointerArray<CPEngContactListModItemContainer>& aServerOrderContacts,

                         const RPointerArray<CPEngContactListModItemContainer>& aOldServerOrder,

                         CPEngContactListModBase& aContactList,

                         TBool aUpdateNickname,

                         HBufC* aContactId,

                         HBufC* aNickName,

                         TInt& aServerIndex,

                         TInt& aOffset,

                         TInt aOldServerCount )

    {

    // get position for insertion

    TInt pos( KErrNotFound );

    if ( KErrNone == aContactList.DoFindContact( aParsedContacts,

                                                 *aContactId,

                                                 pos,

                                                 ETrue ) )

        {

        // contact is twice in the response, server is blabbering

        // Such a contact was already parsed and inserted, ignore it

        CleanupStack::PopAndDestroy( 2 ); // aNickName, aContactId

        return EFalse;

        }

    // does contact already exists?

    // look firs in the server ordered array

    CPEngContactListModItemContainer* cnt = NULL;

    TInt serverIndex( aServerIndex + aOffset );

    if ( serverIndex < aOldServerCount )

        {

        if ( KErrNone == NContactIdsTools::CompareContactIds( aOldServerOrder[ serverIndex ]->Id(),

                                                              *aContactId ) )

            {

            cnt = aOldServerOrder[ serverIndex ];

            }

        else

            {

            serverIndex++;

            // look one ahead, in case some contact was deleted

            if ( ( serverIndex < aOldServerCount ) &&

                 ( KErrNone == NContactIdsTools::CompareContactIds( aOldServerOrder[ serverIndex ]->Id(),

                                                                    *aContactId ) ) )

                {

                // some contact was removed from server array, update offset

                cnt = aOldServerOrder[ serverIndex ];

                aOffset++;

                }

            }

        }

    if ( !cnt )

        {

        cnt = aContactList.FindContactInAll( *aContactId );

        // contact was added to the contact, update offset

        aOffset--;

        }

    if ( cnt )

        {

        // add to the array

        aParsedContacts.InsertL( cnt, pos );

        cnt->Open();                                    // CSI: 65 #

        // check if nick name has changed

        if ( DoIsContactUpdated( *cnt, *aContactId, aNickName ) )

            {

            aContactList.ChangeMonitor().InsertAddedContactIdL( *aContactId );

            // current nick will be updated out of this condition with nick parsed

            // from server response, update New Nick of the Conatct Item container

            if ( aUpdateNickname )

                {

                cnt->RollBackNickname();

                }

            else

                {

                cnt->AdoptCurrentNickAsNew();

                }

            }

        // update contact id as it is given by the network server

        cnt->SetCurrentNickname( aNickName );

        cnt->UpdateContactId( aContactId );

        CleanupStack::Pop( 2 ); // nickName, aContactId

        aServerOrderContacts.AppendL( cnt );

        cnt->SetServerIndex( aServerIndex );

        aServerIndex++;

        return !aContactList.ContactExistsOnServer( *cnt );

        }

    else

        {

        CPEngContactListModItemContainer* newCnt =

            CPEngContactListModItemContainer::NewLC(

                aContactList,

                *aContactId,

                aNickName );

        aParsedContacts.InsertL( newCnt, pos );

        CleanupStack::Pop(); // newCnt

        aContactList.ChangeMonitor().InsertAddedContactIdL( *aContactId );

        CleanupStack::PopAndDestroy( 2 ); // contactId, nickName

        aServerOrderContacts.AppendL( newCnt );

        newCnt->SetServerIndex( aServerIndex );

        aServerIndex++;

        return ETrue;

        }

    }

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

// DoFillChangeMonitorOfRemovedIdsL()

// Fills the monitor of removed contact Ids.

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

//

void DoFillChangeMonitorOfRemovedIdsL(

    CPEngContactListModBase& aContactList,

    const RPointerArray<CPEngContactListModItemContainer>& aNewContacts )

    {

    TInt count( aContactList.Count( EPEngCntListNetworkView ) );

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

        {

        CPEngContactListModItemContainer* cnt =

            static_cast<CPEngContactListModItemContainer*>

            ( &( aContactList.ContactItem(

                     x,

                     EPEngCntListNetworkView ) ) );

        if ( KErrNotFound == aNewContacts.Find( cnt ) )

            {

            aContactList.ChangeMonitor().InsertRemovedContactIdL( cnt->Id() );

            }

        }

    }

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

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

// NListLibTools::LeaveIfMajorErrorL()

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

//

void NListLibTools::LeaveIfMajorErrorL( TInt aError )

    {

    if ( ( aError < 0 ) &&

         ( aError != KErrAlreadyExists ) )

        {

        User::Leave( aError );

        }

    }

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

// NListLibTools::ParseContactListNickListL()

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

//

TBool NListLibTools::ParseContactListNickListL(

    const TDesC8& aResponse,

    RPointerArray<CPEngContactListModItemContainer>& aParsedContacts,

    CPEngContactListModBase& aContactList,

    MPEngXMLParser& aXMLparser1,

    MPEngXMLParser& aXMLparser2,

    TBool aUpdateNickname,

    TInt* aNewContactCount /* NULL */ )

    {

    // check if there is even nick List

    PENG_DP( D_PENG_LIT( "NListLibTools::ParseContactListNickListL::Decode(KNickList)-Start" ) );

    if ( !aXMLparser1.DecodeL( aResponse, KNickList, ETrue ) )

        {

        return EFalse;

        }

    PENG_DP( D_PENG_LIT( "NListLibTools::ParseContactListNickListL::Decode(KNickList)-Done" ) );

    TPtrC8 nickListBlock( aXMLparser1.ResultL( ) );

    TInt newContactCount( 0 );

    RPointerArray<CPEngContactListModItemContainer> serverOrderedContacts;

    CleanupClosePushL( serverOrderedContacts );

    TInt serverOrderIndex( 0 );

    TInt offset( 0 );

    const RPointerArray<CPEngContactListModItemContainer>& oldServerOrder =

        aContactList.ServerOrderedContacts();

    TInt oldServerCount( oldServerOrder.Count() );

    // First parse nicks with nick names

    PENG_DP( D_PENG_LIT( "NListLibTools::ParseContactListNickListL::Decode(KNickName)-Start" ) );

    if ( aXMLparser1.DecodeL( nickListBlock, KNickName, ETrue ) )

        {

        PENG_DP( D_PENG_LIT( "NListLibTools::ParseContactListNickListL::Decode(KNickName)-Done" ) );

        // Assume server ordered it alphabeticaly, used for speed up

        for ( TInt x ( aXMLparser1.Count() - 1 ) ; x >= 0 ; --x )

            {

            HBufC* nickName = NULL;

            HBufC* contactId = NULL;

            if ( aXMLparser2.DecodeL( aXMLparser1.ResultL( x ),

                                      KUserIDXMLTag,

                                      EFalse ) )

                {

                // Get contact Id, does not check if there is wv: prefix

                contactId = aXMLparser2.ResultAsUnicodeTextL();

                CleanupStack::PushL( contactId );

                }

            else

                {

                // XML package is not valid

                User::Leave( KErrGeneral );

                }

            if ( aXMLparser2.DecodeL( aXMLparser1.ResultL( x ),

                                      KName,

                                      EFalse ) )

                {

                nickName = aXMLparser2.ResultAsUnicodeTextL();

                }

            // both contactId and nickName has to be on cleanup stack

            // before calling DoInsertContactLX, ownership is transfered

            CleanupStack::PushL( nickName );

            newContactCount += DoInsertContactLX( aParsedContacts,

                                                  serverOrderedContacts,

                                                  oldServerOrder,

                                                  aContactList,

                                                  aUpdateNickname,

                                                  contactId,

                                                  nickName,

                                                  serverOrderIndex,

                                                  offset,

                                                  oldServerCount );

            }

        PENG_DP( D_PENG_LIT( "NListLibTools::ParseContactListNickListL::Decode(KNickName)-End" ) );

        }

    // now parse all nicks, to find which were without nicks

    PENG_DP( D_PENG_LIT( "NListLibTools::ParseContactListNickListL::Decode(KUserIDXMLTag)-Start" ) );

    if ( aXMLparser1.DecodeL( nickListBlock, KUserIDXMLTag, EFalse ) )

        {

        PENG_DP( D_PENG_LIT( "NListLibTools::ParseContactListNickListL::Decode(KUserIDXMLTag)-Done" ) );

        TInt count ( aXMLparser1.Count() );

        TInt alreadyParsed( serverOrderedContacts.Count() );

        for ( TInt x ( aXMLparser1.Count() - 1 ) ; x >= 0 ; --x )

            {

            HBufC* nickName = NULL;

            HBufC* contactId = aXMLparser1.ResultAsUnicodeTextL( x );

            // try to add contact if it does not match one from

            // already parsed contacts, we can use plain compare->faster

            if ( alreadyParsed &&

                 ( KErrNone == serverOrderedContacts[ 0 ]->Id().Compare( *contactId ) ) )

                {

                delete contactId;

                serverOrderedContacts.Remove( 0 );

                alreadyParsed--;

                continue;

                }

            CleanupStack::PushL( contactId );

            CleanupStack::PushL( nickName );

            // both contactId and nickName has to be on cleanup stack

            // before calling DoInsertContactLX, ownership is transfered

            newContactCount += DoInsertContactLX(

                                   aParsedContacts,

                                   serverOrderedContacts,

                                   oldServerOrder,

                                   aContactList,

                                   aUpdateNickname,

                                   contactId,

                                   nickName,

                                   serverOrderIndex,

                                   offset,

                                   oldServerCount );

            }

        PENG_DP( D_PENG_LIT( "NListLibTools::ParseContactListNickListL::Decode(KUserIDXMLTag)-End" ) );

        }

    CleanupStack::PopAndDestroy(); // serverOrderedContacts

    if ( aNewContactCount )

        {

        *aNewContactCount += newContactCount;

        }

    // Fill monitor of removed contacts

    DoFillChangeMonitorOfRemovedIdsL( aContactList, aParsedContacts );

    PENG_DP( D_PENG_LIT( "NListLibTools::ParseContactListNickListL::-End" ) );

    return ETrue;

    }

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

// NListLibTools::ParseContactListIDsL()

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

//

TBool NListLibTools::ParseContactListIDsL(

    const TDesC8& aResponse,

    RPointerArray<CPEngContactListModItemContainer>& aParsedContacts,

    CPEngContactListModBase& aContactList,

    MPEngXMLParser& aXMLparser1,

    TBool aUpdateNickname,

    TInt* aNewContactCount /* NULL */ )

    {

    TInt newContactCount( 0 );

    RPointerArray<CPEngContactListModItemContainer> serverOrderedContacts;

    CleanupClosePushL( serverOrderedContacts );

    // Parse the list

    if ( aXMLparser1.DecodeL( aResponse, KUserIDXMLTag, EFalse ) )

        {

        HBufC* nickName = NULL;

        HBufC* contactId = NULL;

        TInt serverOrderIndex( 0 );

        TInt offset( 0 );

        const RPointerArray<CPEngContactListModItemContainer>& oldServerOrder =

            aContactList.ServerOrderedContacts();

        TInt oldServerCount( oldServerOrder.Count() );

        for ( TInt x ( aXMLparser1.Count() - 1 ) ; x >= 0 ; --x )

            {

            // Get contact Id

            contactId = aXMLparser1.ResultAsUnicodeTextL( x );

            CleanupStack::PushL( contactId );

            CleanupStack::PushL( nickName );

            // try to add contact

            // both contactId and nickName has to be on cleanup stack

            // before calling DoInsertContactLX, ownership is transfered

            newContactCount += DoInsertContactLX( aParsedContacts,

                                                  serverOrderedContacts,

                                                  oldServerOrder,

                                                  aContactList,

                                                  aUpdateNickname,

                                                  contactId,

                                                  nickName,

                                                  serverOrderIndex,

                                                  offset,

                                                  oldServerCount );

            }

        }

    CleanupStack::PopAndDestroy(); // serverOrderedContacts

    if ( aNewContactCount )

        {

        *aNewContactCount += newContactCount;

        }

    //Fill monitor of removed contacts

    DoFillChangeMonitorOfRemovedIdsL( aContactList, aParsedContacts );

    return ETrue;

    }

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

// NListLibTools::ParseContactListPropertiesL()

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

//

TBool NListLibTools::ParseContactListPropertiesL( const TDesC8& aResponse,

                                                  CPEngContactListSettings& aSettings,

                                                  MPEngXMLParser& aXMLparser1,

                                                  MPEngXMLParser& aXMLparser2 )

    {

    // get a property - Disp name Nick Name tag - UserName Tag

    TBool updateNeeded( EFalse );

    if ( aXMLparser1.DecodeL( aResponse , KProperty, ETrue ) )

        {

        TInt count ( aXMLparser1.Count() );

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

            {

            if ( aXMLparser2.DecodeL( aXMLparser1.ResultL( y ),

                                      KName,

                                      EFalse )

               )

                {

                TBool syncMaster( aSettings.Property(

                                      KPEngCntLstSyncMaster,

                                      KPEngCntLstPropertyNativePermanent ) );

                // name tag is there, get name and setting

                if ( aXMLparser2.ResultL().CompareF( KDispName ) == KErrNone  )

                    {

                    // good here we have a disp name - get it (value)

                    if ( aXMLparser2.DecodeL( aXMLparser1.ResultL( y ),

                                              KValue,

                                              EFalse ) )

                        {

                        HBufC* dispName = aXMLparser2.ResultAsUnicodeTextL();

                        // check if we need some update

                        if ( syncMaster )

                            {

                            CleanupStack::PushL( dispName );

                            // check if disp name is same as at local

                            updateNeeded = ( KErrNone !=

                                             aSettings.DispName().Compare(

                                                 *dispName ) );

                            CleanupStack::PopAndDestroy( dispName );

                            }

                        else

                            {

                            // slave for sync, just store it, safe like this

                            aSettings.PushUpdateDisplayNameL( dispName );

                            }

                        }

                    continue;

                    }

                // parse default flag

                if ( aXMLparser2.ResultL().CompareF( KDefault ) == KErrNone  )

                    {

                    // OK that is settings of the default list

                    // good here we have a disp name - get it (value)

                    if ( aXMLparser2.DecodeL( aXMLparser1.ResultL( y ),