/*
* Copyright (c) 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:  Base class of the contact list management handlers.
*
*/

#include "CPEngContactListMngTransBase.h"

#include "CPEngContactListModChangeMonitor.h"
#include "CPEngContactListSettings.h"

#include "PEngListLibTools.h"
#include "MPEngXMLSerializer.h"
#include "MPEngXMLParser.h"
#include "CPEngTransactionStatus.h"
#include "PEngWVPresenceErrors2.h"
#include "PresenceDebugPrint.h"

#include <e32std.h>

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

// -----------------------------------------------------------------------------
// CPEngContactListMngTransBase::CPEngContactListMngTransBase()
// -----------------------------------------------------------------------------
//
CPEngContactListMngTransBase::CPEngContactListMngTransBase(
    CPEngContactListModBase& aContactList,
    CPEngSessionSlotId& aSessionSlotId,
    TPEngWVCspVersion& aCSPVersion,
    TInt aOperationId )
        : iContactList( aContactList ),
        iSessionSlotId( aSessionSlotId ),
        iCSPVersion( aCSPVersion ),
        iOperationId( aOperationId )
    {
    iContactList.Open();                            // CSI: 65 #
    iContactList.Lock( EStorageLockLevelHigh );
    iContactList.BufferServerSideNotifications();
    }


// -----------------------------------------------------------------------------
// CPEngContactListMngTransBase::ConstructL()
// -----------------------------------------------------------------------------
//
void CPEngContactListMngTransBase::ConstructL()
    {
    iTransactionStatus =  CPEngTransactionStatus::NewL();
    }


// Destructor
CPEngContactListMngTransBase::~CPEngContactListMngTransBase()
    {
    iContactList.ReleaseServerSideBuffering();
    iContactList.Unlock();
    iContactList.Close();
    delete iTransactionStatus;
    delete iRollBackIDsArray;
    }


// ==============================================================================
// =============Function from MPEngOutgoingTransactionHandler =================
// ==============================================================================

// -----------------------------------------------------------------------------
// CPEngContactListMngTransBase::RequestL()
// -----------------------------------------------------------------------------
//
void CPEngContactListMngTransBase::RequestL( TDes8& aSendBuffer )
    {
    // refresh contact from store
    aSendBuffer.Zero();
    MPEngXMLSerializer* xmlSerializer = CreateXmlSerializerL( aSendBuffer );
    CleanupClosePushL( *xmlSerializer );

    // <TransactionContent xmlns="http://www.wireless -village.org/TRC1.1">
    NListLibTools::AppendTransactionContentTagXmlL( *xmlSerializer, iCSPVersion );

    switch ( iUpdateState )
        {
        case EPEngListContentUpdate:
            {
            CPEngContactListMngTransBase::GetXMLContactListUpdateL( *xmlSerializer );
            break;
            }

        case EPEngSubscriptionUpdate:
            {
            DoGetXMLSubscriptionUpdateL( *xmlSerializer );
            break;
            }

        case EPEngRollBack:
            {
            CPEngContactListMngTransBase::GetXMLRollBackUpdateL( *xmlSerializer );
            break;
            }

        default:
            {
            User::Leave( KErrNotSupported );
            break;
            }
        }

    // end of transaction
    // </TransactionContent>
    xmlSerializer->EndTagL( KTransactionContent );
    CleanupStack::PopAndDestroy( ); // xmlSerializer
    }


// -----------------------------------------------------------------------------
// CPEngContactListMngTransBase::LastRunningTransactionHandler()
// -----------------------------------------------------------------------------
//
void CPEngContactListMngTransBase::LastRunningTransactionHandler()
    {
    }


// -----------------------------------------------------------------------------
// CPEngContactListMngTransBase::ProcessResponseL()
// -----------------------------------------------------------------------------
//
void CPEngContactListMngTransBase::ProcessResponseL(
    const TDesC8& aResponse,
    TRequestStatus& /* aStatus */ )
    {
    // is it list update response or subscription update response
    switch ( iUpdateState )
        {
        case EPEngListContentUpdate:
            {
            CPEngContactListMngTransBase::ParseListUpdateResponseL( aResponse );
            break;
            }
        case EPEngSubscriptionUpdate:
            {
            DoParseSubscriptionUpdateResponseL( aResponse );
            break;
            }
        case EPEngRollBack:
            {
            CPEngContactListMngTransBase::ParseListUpdateResponseL( aResponse );
            break;
            }
        default:
            {
            User::Leave( KErrNotSupported );
            }
        }
    }


// -----------------------------------------------------------------------------
// CPEngContactListMngTransBase::CancelProcessing()
// -----------------------------------------------------------------------------
//
void CPEngContactListMngTransBase::CancelProcessing()
    {
    }


// -----------------------------------------------------------------------------
// CPEngContactListMngTransBase::NewTransactionHandlersL()
// -----------------------------------------------------------------------------
//
void CPEngContactListMngTransBase::NewTransactionHandlersL(
    RPointerArray<MPEngOutgoingTransactionHandler>& /* aTransactionsArray*/ )
    {
    }


// -----------------------------------------------------------------------------
// CPEngContactListMngTransBase::TransactionCompleted()
// -----------------------------------------------------------------------------
//
TBool CPEngContactListMngTransBase::TransactionCompleted()
    {
    return ( iUpdateState == EPEngTransactionCompleted );
    }


// -----------------------------------------------------------------------------
// CPEngGetWatchersTransaction::TransactionResult()
// -----------------------------------------------------------------------------
//
CPEngTransactionStatus*  CPEngContactListMngTransBase::TransactionResult()
    {
    CPEngTransactionStatus* temp = iTransactionStatus;
    iTransactionStatus = NULL;
    return temp;
    }


// -----------------------------------------------------------------------------
// CPEngContactListMngTransBase::ReleaseHandler()
// -----------------------------------------------------------------------------
//
void CPEngContactListMngTransBase::ReleaseHandler( )
    {
    iUpdateState = EPEngTransactionCompleted;
    }



// =============================================================================
// ===============Functions of main class ======================================
// =============================================================================

// -----------------------------------------------------------------------------
// CPEngContactListMngTransBase::GetXMLContactListUpdateL()
// -----------------------------------------------------------------------------
//
void CPEngContactListMngTransBase::GetXMLContactListUpdateL(
    MPEngXMLSerializer& aXmlSerializer )
    {
    // <ListManage-Request>
    aXmlSerializer.StartTagL( KListMnageRequest );

    NListLibTools::AppendContactListNameXmlL( aXmlSerializer, iContactList.Settings() );

    DoAppendListNickUpdateL( aXmlSerializer );

    // <ReceiveList>T</ReceiveList>
    NListLibTools::ApppendReceiveListTagL( aXmlSerializer, iCSPVersion, ETrue );

    // </ListManage-Request>
    aXmlSerializer.EndTagL( KListMnageRequest );
    }


// -----------------------------------------------------------------------------
// CPEngContactListMngTransBase::GetXMLRollBackUpdateL()
// -----------------------------------------------------------------------------
//
void CPEngContactListMngTransBase::GetXMLRollBackUpdateL(
    MPEngXMLSerializer& aXmlSerializer )
    {
    // <ListManage-Request>
    aXmlSerializer.StartTagL( KListMnageRequest );

    NListLibTools::AppendContactListNameXmlL( aXmlSerializer, iContactList.Settings() );

    // <RemoveNickList>
    aXmlSerializer.StartTagL( KRemoveNickList );

    // insert contact Ids for rollback
    TInt count( iRollBackIDsArray->Count() );
    for ( TInt x( 0 ); x < count ; x++ )
        {
        // <UserID>
        // Contact list id value
        // </UserID>
        aXmlSerializer.StartTagL( KUserIDXMLTag
                                ).WvAddressL( iRollBackIDsArray->MdcaPoint( x )
                                            ).EndTagL( KUserIDXMLTag );
        }

    // </RemoveNickList>
    aXmlSerializer.EndTagL( KRemoveNickList );

    // <ReceiveList>T</ReceiveList>
    NListLibTools::ApppendReceiveListTagL( aXmlSerializer, iCSPVersion, ETrue );

    // </ListManage-Request>
    aXmlSerializer.EndTagL( KListMnageRequest );
    }


// -----------------------------------------------------------------------------
// CPEngContactListMngTransBase::ParseListUpdateResponseL()
// -----------------------------------------------------------------------------
//
void CPEngContactListMngTransBase::ParseListUpdateResponseL(
    const TDesC8& aResponse )
    {
    PENG_DP( D_PENG_LIT( "CPEngContactListMngTransBase::ParseListUpdateResponseL() [%S]" ),
             &( iContactList.ListProperties().Name() ) );

    // clean attribute models if this is roll back
    if ( iUpdateState == EPEngRollBack )
        {
        NListLibTools::DeactivatePresenceAttributesL( *iRollBackIDsArray, iSessionSlotId );
        }

    // consume response
    CPEngTransactionStatus* transactionStatus = CPEngTransactionStatus::NewL();
    CleanupClosePushL( *transactionStatus );

    MPEngXMLParser* xMLparser1 = CreateXMLParserLC();
    TInt err ( xMLparser1->ParseContactListResultL( aResponse,
                                                    iOperationId,
                                                    iContactList.StorageId(),
                                                    *transactionStatus ) );

    MPEngXMLParser* xMLparser2 = CreateXMLParserLC();
    switch ( err )
        {
        case KErrNone:
        case KPEngNwErrPartiallySuccessful:
            {
            // try to parse Nick list at any case, can be that Server is giving us
            // hook what is at the moment on the contact list
            // get one more parser for this part
            RReffArray<CPEngContactListModItemContainer> newContacts;
            CleanupClosePushL( newContacts );
            if ( NListLibTools::ParseContactListNickListL( aResponse,
                                                           newContacts,
                                                           iContactList,
                                                           *xMLparser1,
                                                           *xMLparser2,
                                                           ETrue,
                                                           &iNewIdsCount ) )
                {
                iContactList.AdoptNetworkViewL( newContacts );
                // remove bad contacts from the
                NListLibTools::RemoveBadContactsL( *transactionStatus, iContactList );
                }
            else
                {
                // nick list was not there, consume result manually
                NListLibTools::RemoveBadContactsL( *transactionStatus, iContactList );
                // complete contact list update
                DoCompleteContactListUpdateL();
                }

            CleanupStack::PopAndDestroy(); // newContacts
            DoUpdateTransactionState();
            break;
            }


        case KPEngNwErrUnknownUser:
        case KPEngNwErrServiceUnavailable:
        case KPEngNwErrBadParameter:
        default:
            {
            iTransactionStatus->SetStatus( transactionStatus->Status() );
            transactionStatus->Reset();

            iUpdateState =  EPEngTransactionCompleted;
            //  fill manually transaction result
            RPointerArray<CPEngContactListModItemContainer> nickList;
            DoFillNickListLC( nickList );
            // go through array from end
            TInt contactCount ( nickList.Count() - 1 );
            for (  ; contactCount >= 0 ; --contactCount )
                {
                CPEngContactListModItemContainer* entry = nickList[ contactCount ];


                // add bad contact it to the transaction status
                TPtrC badContactId ( entry->Id() );

                iTransactionStatus->AddDetailedResultL(
                    iOperationId,
                    KPEngNwErrUnknownUser,
                    NULL,
                    &badContactId,
                    &( iContactList.StorageId() ),
                    NULL );

                if ( entry->IsFreshContact() )
                    {
                    iContactList.RemoveBadContactL( badContactId );
                    }
                else
                    {
                    entry->RollBackNickname();
                    iContactList.StoreL();
                    }
                }

            CleanupStack::PopAndDestroy(); // nickList

            // try to parse response if there was contact list content
            RReffArray<CPEngContactListModItemContainer> newContacts;
            CleanupClosePushL( newContacts );
            if ( NListLibTools::ParseContactListNickListL( aResponse,
                                                           newContacts,
                                                           iContactList,
                                                           *xMLparser1,
                                                           *xMLparser2,
                                                           ETrue ) )
                {
                iContactList.AdoptNetworkViewL( newContacts );
                }

            CleanupStack::PopAndDestroy(); // newContacts
            break;
            }
        }


    // register new added contact Ids if this is subscription
    if ( ( iUpdateState == EPEngSubscriptionUpdate ) ||
         ( iUpdateState == EPEngActivateAttributes ) )
        {
        CPEngContactListModChangeMonitor& changeMonitor = iContactList.ChangeMonitor();
        NListLibTools::ActivatePresenceAttributesL( changeMonitor.AddedContactIds(),
                                                    iSessionSlotId );
        // update state if needed
        iUpdateState = ( iUpdateState == EPEngActivateAttributes ? EPEngTransactionCompleted
                         : iUpdateState );
        }


    // deactivate removed contact Ids if needed
    if ( iUpdateState == EPEngDeActivateAttributes )
        {
        CPEngContactListModChangeMonitor& changeMonitor = iContactList.ChangeMonitor();
        NListLibTools::DeactivatePresenceAttributesL( changeMonitor.RemovedContactIds(),
                                                      iSessionSlotId );
        iUpdateState = EPEngTransactionCompleted;
        }


    CleanupStack::PopAndDestroy( 2 ); // xMLparser2, xMLparser1

    iTransactionStatus->ImportStatusFrom( *transactionStatus );
    CleanupStack::Pop(); // transactionStatus

    PENG_DP( D_PENG_LIT( "CPEngContactListMngTransBase::ParseListUpdateResponseL() done [%S]" ),
             &( iContactList.ListProperties().Name() ) );
    }

//  End of File