/*
* Copyright (c) 2006-2008 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:  
*
*/


#include "ncdcreateaccesspointoperationimpl.h"

#include <s32mem.h>
#include <apmstd.h>

#include "catalogsbasemessage.h"
#include "catalogsutils.h"
#include "catalogscontext.h"
#include "catalogsaccesspointmanager.h"
#include "ncdproviderdefines.h"
#include "ncdparserfactory.h"
#include "ncdparser.h"

#include "ncd_cp_query.h"
#include "ncd_cp_queryelement.h"
#include "ncd_cp_queryoption.h"
#include "ncd_cp_detail.h"
#include "ncd_cp_clientconfiguration.h"
#include "ncd_cp_error.h"
#include "ncd_cp_serverdetails.h"
#include "ncd_cp_actionrequest.h"
#include "ncd_cp_queryresponseimpl.h"
#include "ncdparserimpl.h"
#include "ncd_parser_cp_clientconfiguration.h"
#include "ncdgeneralmanager.h"

#include "catalogsdebug.h"

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

// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------
//
CNcdCreateAccessPointOperation* CNcdCreateAccessPointOperation::NewL( 
    HBufC* aAccessPointData,
    MNcdOperationRemoveHandler& aRemoveHandler, 
    CNcdGeneralManager& aGeneralManager,
    MCatalogsSession& aSession )
    {
    CNcdCreateAccessPointOperation* self = 
        new( ELeave ) CNcdCreateAccessPointOperation( 
            aRemoveHandler, 
            aGeneralManager,
            aSession );
        
    CleanupClosePushL( *self );
    self->ConstructL( aAccessPointData );
    CleanupStack::Pop();
    return self;
    }


// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CNcdCreateAccessPointOperation::~CNcdCreateAccessPointOperation()
    {
    DLTRACEIN(( "" ));    
    delete iParser;
    delete iAccessPointData; 
       
    }


// ---------------------------------------------------------------------------
// Cancel
// ---------------------------------------------------------------------------
//
void CNcdCreateAccessPointOperation::Cancel() 
    {    
    DLTRACEIN(( "" ));
    if ( iParser ) 
        {
        iParser->CancelParsing();
        }
    iOperationState = EStateCancelled;
    
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdCreateAccessPointOperation::ParseError( TInt aErrorCode )
    {
    DLTRACEIN(("error:%d", aErrorCode ));
    
    // Handle error only if not handling an error already
    // (cancellation of parsing may cause an unnecessary call to this function).
    if( iError == KErrNone )
        {
        iError = aErrorCode;
           
        if ( iParser )
            {
            iParser->CancelParsing();
            }
                    
        iOperationState = EStateComplete;     
        RunOperation();
        }
    }

// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
void CNcdCreateAccessPointOperation::ParseCompleteL( TInt aError )
    {
    DLTRACEIN(("error: %d", aError ));

    if ( aError == KErrNone ) 
        {        
        ParseAccessPointDataL();
        }
    
    delete iParser;
    iParser = NULL;

    iOperationState = EStateComplete; 
    iError = aError;
        
    RunOperation();
    }


// ---------------------------------------------------------------------------
// RunOperation
// ---------------------------------------------------------------------------
//
TInt CNcdCreateAccessPointOperation::RunOperation()
    {
    DLTRACEIN(( "Pending message: %X", iPendingMessage ));    
    
    if ( !iPendingMessage ) 
        {      
        DLTRACE(("No pending message"));  
        return KErrNotReady;
        }
    
    // One trap to rule them all
    TRAPD( err, HandleStateL() );
    
    HandleError( err );
    DLTRACEOUT(("err: %d", err));
    return err;
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdCreateAccessPointOperation::HandleStateL() 
    {
    DLTRACEIN((""));
    switch( iOperationState ) 
        {
        case EStateRunning:
            {
            StartParsingL();            
            break;
            }
              
              
        case EStateComplete:
            {
            if ( !iError && !iAccessPoint ) 
                {
                DLERROR(("No accesspoint was created, error KErrNotFound"));
                iError = KErrNotFound;
                }
                
            // Returns false if there was no error
            if ( !HandleError( iError ) ) 
                {
                DLTRACE(("Completing the operation"));
                iProgress.iProgress = iAccessPoint;
                CNcdBaseOperation::CompleteMessage( 
                    iPendingMessage,
                    ENCDOperationMessageCompletionComplete, 
                    iProgress,
                    KErrNone );
                }
            break;
            }
        
        default: 
            {
            DLTRACE(("Default"));
            break;
            }
        }    
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TBool CNcdCreateAccessPointOperation::HandleError( TInt aError ) 
    {
    DLTRACEIN(("aError: %d", aError ));
    if ( aError != KErrNone ) 
        {
        DLERROR(("Error %d occurred", aError ));
        iError = aError;
        iOperationState = EStateCancelled;
        Cancel();
        if ( iPendingMessage )
            {
            // ignoring error because operation already failed
            CNcdBaseOperation::CompleteMessage( iPendingMessage,
                ENCDOperationMessageCompletionError, iError );
            }
        return ETrue;
        }    
    return EFalse;
    }
    

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdCreateAccessPointOperation::StartParsingL()
    {
    DLTRACEIN((""));
    // create parser
    delete iParser;
    iParser = NULL;
    iParser = NcdParserFactory::CreateParserL( NULL );    
        
    MNcdParserObserverBundle& observers = iParser->Observers();
    observers.SetParserObserver( this );            
    
    
    iSubParser = 
        CNcdConfigurationProtocolClientConfigurationParser::NewL( 
            observers, *static_cast<CNcdParserImpl*>( iParser ), 0 );
            
    iParser->BeginAsyncL( iSubParser ); // ownership is transferred
    
    DLTRACE(("Start parsing the data"));
    iParser->ParseL( *iAccessPointData );
    // Inform parser that no more data will be sent
    iParser->EndL();    
    }
    

// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
void CNcdCreateAccessPointOperation::ParseAccessPointDataL() 
    {
    DLTRACEIN((""));
    // Ownership is transferred here
    MNcdConfigurationProtocolClientConfiguration* configuration = 
        iSubParser->ClientConfiguration();

    if ( !configuration ) 
        {
        DLTRACEOUT(("No configuration"));
        return;
        }
        
    CleanupDeletePushL( configuration );
    DASSERT( iPendingMessage );
    
    RArray<TUint32> accesspoints;
    CleanupClosePushL( accesspoints );
    // Parse access point data from client configuration response.
    iGeneralManager.AccessPointManager().ParseAccessPointDataFromClientConfL(
        *configuration, 
        iPendingMessage->Session().Context().FamilyId(),
        ETrue,
        &accesspoints );
        
    iAccessPoint = 0;
    
    if ( accesspoints.Count() ) 
        {
        DLTRACE(("%d accesspoints were created", accesspoints.Count() ));
        iAccessPoint = accesspoints[0];
        DLTRACE(("iAccessPoint: %d", iAccessPoint ));
        }
     
    CleanupStack::PopAndDestroy( 2, configuration ); // accesspoints, aConfiguration    
    }
    

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CNcdCreateAccessPointOperation::CNcdCreateAccessPointOperation(
    MNcdOperationRemoveHandler& aRemoveHandler, 
    CNcdGeneralManager& aGeneralManager,
    MCatalogsSession& aSession )
    :
    CNcdBaseOperation( aGeneralManager, &aRemoveHandler, ECreateAccessPointOperation,
        aSession )    
    {
    }


// ---------------------------------------------------------------------------
// ConstructL
// ---------------------------------------------------------------------------
//
void CNcdCreateAccessPointOperation::ConstructL(
    HBufC* aAccessPointData )
    {
    DLTRACEIN( ( "" ) );

    // Call ConstructL for the base class
    CNcdBaseOperation::ConstructL();

    iAccessPointData = aAccessPointData;

    }