/*
* 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:  Transction handler to do basic synchronization
*
*/


// INCLUDE FILES
#include "CPEngStartSyncTransaction.h"

#include "MPEngContactListTransactionManager.h"
#include "CPEngContactListSettings.h"
#include "CPEngContactListModBase.h"

#include "MPEngTransactionFactory.h"

#include "PEngListLibTools.h"
#include "MPEngXMLSerializer.h"
#include "MPEngXMLParser.h"

#include "PEngContactIdsTools.h"
#include "CPEngTransactionStatus.h"
#include "PEngWVPresenceErrors2.h"
#include "PresenceDebugPrint.h"


//Default granurality for list of lists
const TInt KListOfListGranurality = 5;


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

// -----------------------------------------------------------------------------
// CPEngStartSyncTransaction::CPEngStartSyncTransaction()
// -----------------------------------------------------------------------------
//
CPEngStartSyncTransaction::CPEngStartSyncTransaction(
    MPEngContactListTransactionManager& aCntLstSettingsManager,
    TPEngWVCspVersion& aCSPVersion,
    TInt aOperationId,
    TBool aNeedToUnsubscribe )
        : iContactListManager( aCntLstSettingsManager ),
        iSynchronizationState( EPEngGetListOfLists ),
        iServerCntLists( KListOfListGranurality ),
        iCSPVersion( aCSPVersion ),
        iOperationId( aOperationId ),
        iUnsubscribe( aNeedToUnsubscribe )
    {
    PENG_DP( D_PENG_LIT( "CPEngStartSyncTransaction::CPEngStartSyncTransaction()" ) );
    }


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


// -----------------------------------------------------------------------------
// CPEngStartSyncTransaction::NewLC()
// -----------------------------------------------------------------------------
//
CPEngStartSyncTransaction* CPEngStartSyncTransaction::NewLC(
    MPEngContactListTransactionManager& aCntLstSettingsManager,
    TPEngWVCspVersion& aCSPVersion,
    TInt aOperationId,
    TBool aNeedToUnsubscribe )
    {
    CPEngStartSyncTransaction* self = new ( ELeave ) CPEngStartSyncTransaction(
        aCntLstSettingsManager,
        aCSPVersion,
        aOperationId,
        aNeedToUnsubscribe );

    CleanupStack::PushL( self );
    self->ConstructL( );

    return self;
    }


// Destructor
CPEngStartSyncTransaction::~CPEngStartSyncTransaction()
    {
    PENG_DP( D_PENG_LIT( "CPEngStartSyncTransaction::~CPEngStartSyncTransaction()" ) );
    delete iTransactionStatus;
    iServerCntLists.Reset();
    delete iDefaultCntList;
    }


// ==============================================================================
// ============= Functions from MPEngOutgoingTransactionHandler =================
// ==============================================================================

// -----------------------------------------------------------------------------
// CPEngStartSyncTransaction::RequestL()
// -----------------------------------------------------------------------------
//
void CPEngStartSyncTransaction::RequestL( TDes8& aSendBuffer )
    {
    aSendBuffer.Zero();
    MPEngXMLSerializer* xmlSerializer = CreateXmlSerializerL( aSendBuffer );
    CleanupClosePushL( *xmlSerializer );

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

    switch ( iSynchronizationState )
        {
        case EPEngGetListOfLists:
            {
            GetXMLGetListOfContactListsL( *xmlSerializer );
            break;
            }

        case EPEngUnSubscribe:
            {
            GetXMLUnsubscribeAllL( *xmlSerializer );
            break;
            }

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

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


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


// -----------------------------------------------------------------------------
// CPEngStartSyncTransaction::ProcessResponseL()
// -----------------------------------------------------------------------------
//
void CPEngStartSyncTransaction::ProcessResponseL( const TDesC8& aResponse,
                                                  TRequestStatus& /* aStatus */ )
    {
    PENG_DP( D_PENG_LIT( "CPEngStartSyncTransaction::ProcessResponseL()" ) );

    // transaction to server was successful
    MPEngXMLParser* XMLparser = CreateXMLParserLC();

    switch ( iSynchronizationState )
        {
        case EPEngGetListOfLists:
            {
            ParseGetListOfListsResponseL( aResponse, XMLparser );
            break;
            }

        case EPEngUnSubscribe:
            {
            ParseUnsubscreAllResponseL( aResponse, XMLparser );
            break;
            }

        default:
            {
            User::Leave( KErrCorrupt );
            }
        }

    CleanupStack::PopAndDestroy(); // XMLparser
    }


// -----------------------------------------------------------------------------
// CPEngStartSyncTransaction::ProcessResponseL()
// -----------------------------------------------------------------------------
//
void CPEngStartSyncTransaction::CancelProcessing()
    {
    }


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


// -----------------------------------------------------------------------------
// CPEngStartSyncTransaction::TransactionCompleted()
// -----------------------------------------------------------------------------
//
TBool CPEngStartSyncTransaction::TransactionCompleted()
    {
    return ( iSynchronizationState == EPEngTransactionCompleted );
    }


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


// -----------------------------------------------------------------------------
// CPEngStartSyncTransaction::ReleaseHandler()
// -----------------------------------------------------------------------------
//
void CPEngStartSyncTransaction::ReleaseHandler()
    {
    iSynchronizationState = EPEngTransactionCompleted;
    }


// -----------------------------------------------------------------------------
// CPEngStartSyncTransaction::GetXMLContactListUpdateL()
// -----------------------------------------------------------------------------
//
void CPEngStartSyncTransaction::GetXMLGetListOfContactListsL(
    MPEngXMLSerializer& aXmlSerializer )
    {
    // get lists of the contact lists of the server
    aXmlSerializer.StartTagL( KGetListOfList ).EndTagL( KGetListOfList );
    }

// -----------------------------------------------------------------------------
// CPEngStartSyncTransaction::GetXMLContactListUpdateL()
// -----------------------------------------------------------------------------
//
void CPEngStartSyncTransaction::GetXMLUnsubscribeAllL(
    MPEngXMLSerializer& aXmlSerializer )
    {
    // <UnsubscribePresence-Request>
    aXmlSerializer.StartTagL( KUnsubscribePresence );

    // add all contact lists which are on the server
    TInt count( iServerCntLists.Count() );
    for ( TInt x( 0 ) ; x < count ; x++ )
        {
        // <ContactList>
        // append name of the contact list
        // </ContactList>
        aXmlSerializer.StartTagL( KContactList
                                ).WvAddressL( iServerCntLists[ x ]
                                            ).EndTagL( KContactList );
        }

    //  </UnsubscribePresence-Request>
    aXmlSerializer.EndTagL( KUnsubscribePresence );
    }


// -----------------------------------------------------------------------------
// CPEngStartSyncTransaction::ParseGetListOfListsResponseL()
// -----------------------------------------------------------------------------
//
void CPEngStartSyncTransaction::ParseGetListOfListsResponseL(
    const TDesC8& aResponse,
    MPEngXMLParser* aXMLparser )
    {
    iServerCntLists.Reset();

    // initialize to EFalse, we don't necessarily need the result
    TBool result( EFalse );
    aXMLparser->ParseResultL( aResponse,
                              iOperationId,
                              *iTransactionStatus,
                              result );

    //if it was found anyway
    if ( result )
        {
        iSynchronizationState = EPEngTransactionCompleted;
        return;
        }

    // Is there default contact list
    if ( aXMLparser->DecodeL( aResponse, KDefaultContactList, EFalse ) )
        {
        iDefaultCntList = aXMLparser->ResultAsUnicodeTextL();
        iDefaultCntList->Des().Fold();
        iServerCntLists.AppendL( *iDefaultCntList );
        }
    else
        {
        iDefaultCntList = KNullDesC().AllocL();
        }


    const TDesC& domain = iContactListManager.UserDomain();
    if ( aXMLparser->DecodeL( aResponse, KContactList, EFalse ) )
        {
        TInt countResults( aXMLparser->Count() );
        for ( TInt i( 0 ) ; i < countResults; ++i )
            {
            // convert to 16 unicode
            HBufC16* listName = aXMLparser->ResultAsUnicodeTextL( i );
            CleanupStack::PushL( listName );
            listName->Des().Fold();
            NContactIdsTools::AddContactIdToArrayL( iServerCntLists,
                                                    *listName,
                                                    domain );
            CleanupStack::PopAndDestroy();
            }
        }

    if ( iUnsubscribe )
        {
        iSynchronizationState = EPEngUnSubscribe;
        }
    else
        {
        iSynchronizationState = EPEngTransactionCompleted;
        iContactListManager.CompleteEnviromentSyncL( iServerCntLists,
                                                     KNullDesC,
                                                     EFalse );
        }
    }


// -----------------------------------------------------------------------------
// CPEngStartSyncTransaction::ParseUnsubscreAllResponseL()
// -----------------------------------------------------------------------------
//
void CPEngStartSyncTransaction::ParseUnsubscreAllResponseL(
    const TDesC8& aResponse,
    MPEngXMLParser* aXMLparser )
    {
    CPEngTransactionStatus* transactionStatus = CPEngTransactionStatus::NewL();
    CleanupClosePushL( *transactionStatus );
    TInt err ( aXMLparser->ParseResultL( aResponse,
                                         iOperationId,
                                         *transactionStatus ) );

    switch ( err )
        {
        case KErrNone:
            {
            break;
            }


        case KPEngNwErrPartiallySuccessful:
            {
            // partially success
            // remove not existing contact lists, though, should not happen
            TInt count ( transactionStatus->DetailedResultCount() );
            for ( TInt x ( 0 ) ; x < count ; x++ )
                {
                const MPEngDetailedResultEntry2& detailedResult =
                    transactionStatus->DetailedResult( x );

                // ignore if there are some errors, except wrong contact list
                if ( detailedResult.Error() == KPEngNwErrContactListDoesNotExist )
                    {
                    // not existing contact list, remove it from list
                    // of server lists
                    TPtrC wrongContactLst;
                    detailedResult.GetDetailedDesc( wrongContactLst,
                                                    EPEngDTContactListID );
                    TInt pos( KErrNotFound );
                    if ( KErrNone == iServerCntLists.Find( wrongContactLst, pos ) )
                        {
                        iServerCntLists.Delete( pos );
                        }
                    }
                }

            break;
            }


        case KPEngNwErrContactListDoesNotExist:
            {
            iServerCntLists.Reset();
            delete iDefaultCntList;
            iDefaultCntList = NULL;
            iDefaultCntList = KNullDesC().AllocL();
            break;
            }

        default:
            {
            break;
            }
        }

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

    iContactListManager.CompleteEnviromentSyncL( iServerCntLists,
                                                 *iDefaultCntList,
                                                 ETrue );

    iSynchronizationState = EPEngTransactionCompleted;
    }

//  End of File