/*
* 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:  
*
*/


#ifndef C_NCDLOADBUNDLENODEOPERATIONIMPL_H
#define C_NCDLOADBUNDLENODEOPERATIONIMPL_H

#include <e32base.h>
#include <badesca.h>
#include "ncdbaseoperation.h"
#include "ncdconfigurationobserver.h"

class MCatalogsAccessPointManager;
class MNcdProtocol;
class MNcdConfigurationManager;
class CNcdContentSource;
class CNcdNodeIdentifier;
class CNcdLoadNodeOperationImpl;
class CNcdContentSourceMap;
class CNcdChildEntityMap;
class MNcdOperationQueue;
class CNcdNodeMetaData;

/**
 *  Load node operation implementation.
 *
 *  Handles the "loading of root node" i.e. creates
 *  a root node from a conf protocol response.
 *
 *  @lib ?library
 *  @since S60 ?S60_version *** for example, S60 v3.0
 */
class CNcdLoadBundleNodeOperation : public CNcdBaseOperation,
                                    public MNcdParserObserver,
                                    public MCatalogsHttpObserver,
                                    public MNcdParserConfigurationProtocolObserver,
                                    public MNcdConfigurationObserver
    {
    
public:

    /** Sub states of bundle node operation */
    enum TBundleNodeState
        {
        EConfRequest,      // create and send a conf request
        EReceiveConf,      // receive and parse conf data
        EConfQuery,        // respond to conf query
        EBrowseRequest,    // create sub-operations 
        EReceiveBrowse,    // wait for sub-operations to complete
        EComplete,         // everything done
        EFailed            // operation failed
        };
    
    
    static CNcdLoadBundleNodeOperation* NewL(
        const CNcdNodeIdentifier& aNodeIdentifier,
        CNcdGeneralManager& aGeneralManager,
        MCatalogsHttpSession& aHttpSession,
        MNcdOperationRemoveHandler* aRemoveHandler,
        MNcdOperationQueue& aOperationQueue,
        MCatalogsSession& aSession );

    static CNcdLoadBundleNodeOperation* NewLC(
        const CNcdNodeIdentifier& aNodeIdentifier,
        CNcdGeneralManager& aGeneralManager,
        MCatalogsHttpSession& aHttpSession,
        MNcdOperationRemoveHandler* aRemoveHandler,
        MNcdOperationQueue& aOperationQueue,
        MCatalogsSession& aSession );

    virtual ~CNcdLoadBundleNodeOperation();
    
    /**
     * Returns the identifier of the parent node this operation is loading.
     *
     * @return Identifier of the parent node.
     */
    const CNcdNodeIdentifier& NodeIdentifier() const;

    
public: //from CNcdBaseOperation

    /**
     * Starts the operation.
     */
    virtual TInt Start();

    /**
     * @see CNcdBaseOperation::Cancel
     */
    virtual void Cancel();
    
    /**
     * @see CNcdBaseOperation::HandleCancelMessage
     */
    virtual void HandleCancelMessage( MCatalogsBaseMessage* aMessage );

    /**
     * @see CNcdBaseOperation::CompleteMessage         
     */
    virtual TInt CompleteMessage( MCatalogsBaseMessage* & aMessage,
        TNcdOperationMessageCompletionId aId,
        const MNcdSendable& aSendableObject,
        TInt aStatus );
        
    /**
     * @see CNcdBaseOperation::CompleteMessage         
     */
    virtual TInt CompleteMessage( MCatalogsBaseMessage* & aMessage,
        TNcdOperationMessageCompletionId aId,
        TInt aStatus );
        
    /**
     * @see CNcdBaseOperation::CompleteMessage         
     */
    virtual TInt CompleteMessage( MCatalogsBaseMessage*& aMessage,
        TNcdOperationMessageCompletionId aId,
        const MNcdSendable& aSendableObject,
        RPointerArray<CNcdNodeIdentifier>& aNodes,
        TInt aStatus );
        
    /**
     * @see CNcdBaseOperation::CompleteMessage         
     */
    virtual TInt CompleteMessage( MCatalogsBaseMessage*& aMessage,
        TNcdOperationMessageCompletionId aId,
        RPointerArray<CNcdExpiredNode>& aExpiredNodes,
        TInt aStatus );
    
    
public: // from MCatalogsHttpObserver

    /**     
     * @see MCatalogsHttpObserver::HandleHttpEventL
     */
    virtual void HandleHttpEventL( 
        MCatalogsHttpOperation& aOperation, 
        TCatalogsHttpEvent aEvent );
        
    /**
     * @see MCatalogsHttpObserver::HandleHttpError()
     */
    TBool HandleHttpError(
        MCatalogsHttpOperation& aOperation,
        TCatalogsHttpError aError );
        
public: //from MNcdParserObserver

    /**
     * @see MNcdParserObserver
     */
    virtual void ParseError( TInt aErrorCode );

    /**
     * @see MNcdParserObserver
     */
    virtual void ParseCompleteL( TInt aError );
    
public: // from MNcdParserConfigurationProtocolObserver

    virtual void ConfigurationBeginL( const TDesC& aVersion, 
                                      TInt aExpirationDelta );
    virtual void ConfigurationQueryL( MNcdConfigurationProtocolQuery* aQuery );

    virtual void ClientConfigurationL(
        MNcdConfigurationProtocolClientConfiguration* aConfiguration );
    virtual void ConfigurationDetailsL( 
        CArrayPtr<MNcdConfigurationProtocolDetail>* aDetails );
    virtual void ConfigurationActionRequestL(
        MNcdConfigurationProtocolActionRequest* aActionRequest );
    virtual void ConfigurationErrorL( MNcdConfigurationProtocolError* aError );
    virtual void ConfigurationServerDetailsL( MNcdConfigurationProtocolServerDetails* aServerDetails );
    virtual void ConfigurationEndL();

public: // from MNcdOperationObserver
    
    /**
     * @see MNcdOperationObserver
     */
    virtual void Progress( CNcdBaseOperation& aOperation );
    
    /**
     * @see MNcdOperationObserver
     */
    virtual void QueryReceived( CNcdBaseOperation& aOperation,
                                 CNcdQuery* aQuery );

    /**
     * @see MNcdOperationObserver
     */
    virtual void OperationComplete( CNcdBaseOperation* aOperation,
                                    TInt aError );
                                    
public: // from MNcdConfigurationObserver

    virtual void ConfigurationChangedL();                                   
                                    
public: // from CCatalogsCommunicable
    
    /**
     * @see CCatalogsCommunicable
     */
    virtual void ReceiveMessage( 
        MCatalogsBaseMessage* aMessage,
        TInt aFunctionNumber );
        
public: // from MNcdParserErrorObserver

    virtual void ErrorL( MNcdPreminetProtocolError* aData );
                                    

protected:

    CNcdLoadBundleNodeOperation(
        CNcdGeneralManager& aGeneralManager,
        MCatalogsHttpSession& aHttpSession,
        MNcdOperationRemoveHandler* aRemoveHandler,
        MNcdOperationQueue& aOperationQueue,
        MCatalogsSession& aSession );
    
    void ConstructL( const CNcdNodeIdentifier& aNodeIdentifier );
    
    HBufC8* CreateConfRequestLC( CNcdQuery* aQuery = NULL );

    /**
     * Reverts the nodes which could not be retrieved due to broken content
     * source from NodeManager's temp cache to main RAM cache.
     */
    void RevertNodesOfBrokenSourcesToCacheL();
    
    /**
     * Reverts the given node belonging to given content source from
     * NodeManager's temp cache to the main cache.
     */
    void RevertNodeL(
        const CNcdNodeIdentifier& aNodeIdentifier,
        const CNcdContentSource& aContentSource );
    /**
     * Removes the nodes that were removed from content sources.
     */
    void RemoveOldNodesL();
    
    /**
     * Adds the bundle node identifier to iLoadedNodes.
     */
    void AddBundleToLoadedNodesL();
    
    /**
     * Updates the root node's content source map according to the new
     * content sources of the loaded bundle.
     */
    void UpdateCsMapToRootNodeL();
    
    /**
     * Sets always visible flags to the metadata of the nodes that belong to
     * content sources defined as always visible in client configuration.
     */
    void SetAlwaysVisibleFlagsL();
    
    void ParseCatalogBundleL( const MNcdConfigurationProtocolDetail& aDetail );
    
    /**
     * Notifies the operation manager about completion of a queued operation,
     * if the given completion id indicates that the operation is really completed.
     *
     * @param aId The completion id.
     */
    void NotifyCompletionOfQueuedOperation( TNcdOperationMessageCompletionId aId );    
    
    static TBool ContainsNode(
        const RPointerArray<CNcdNodeIdentifier>& aNodes,
        const CNcdNodeIdentifier& aNode);
    
    void HandleBundleDisclaimerL(
        CNcdNodeMetaData& aMetadata, 
        const TDesC& aDisclaimer );
    

protected:

    void HandleConfigurationDataRequestMessage( MCatalogsBaseMessage& aMessage );
    
    
protected: // from CNcdBaseOperation

    /**
     * @see CNcdBaseOperation::RunOperation
     */
    virtual TInt RunOperation();
    
    void DoRunOperationL();
    
    /**
     * @see CNcdBaseOperation::RunOperation
     */
    virtual void ChangeToPreviousStateL();
    
    virtual TBool QueryCompletedL( CNcdQuery* aQuery );
    
private: // type declarations
    
    /** Sub states of master server redirection process */
    enum TMasterServerRedirectionState 
        {
        EBegin, // Start state.
        ERedirecting, // Redirecting.
        EReverted // Returned to use previous master server address.
        };

private: // data
    /**
     * A sub-state of this operation's execution.
     */
    TBundleNodeState iBundleNodeState;
    
    /**
     * A sub-state of master server redirection.
     */
    TMasterServerRedirectionState iMasterServerRedirectionState;
    
    /**
     * Nodes that have been loaded. This is used to store loaded
     * nodes identifiers before they can be sent to the proxy in a message.
     */
    RPointerArray<CNcdNodeIdentifier> iLoadedNodes;
        
    /**
     * This flag is set to indicate that progress info should be sent
     * when the next message is received.
     */
    TBool iSendProgress;    
        
    /**
     * Access point manager for creating access points.
     */
    MCatalogsAccessPointManager& iAccessPointManager;
    

    /**
     * Http session for sending requests and receiving responses.
     * Not own.
     */
    MCatalogsHttpSession& iHttpSession;

    MNcdProtocol& iProtocol;
    
    /**
     * Configuration manager for getting the Master Server Address
     */
    MNcdConfigurationManager& iConfigManager;
        
    /**
     * Http operation for current transaction.
     * Not own.
     */
    MCatalogsHttpOperation* iTransaction;
        
    /**
     * Sub-operations for browse requests.
     */
    RPointerArray<CNcdLoadNodeOperationImpl> iSubOps;
    RPointerArray<CNcdLoadNodeOperationImpl> iFailedSubOps;
    RPointerArray<CNcdLoadNodeOperationImpl> iCompletedSubOps;
        
    /**
     * Content sources are stored here.
     */
    CNcdContentSourceMap* iContentSourceMap;
    
    /**
     * Identifier of the bundle node.
     */
    CNcdNodeIdentifier* iNodeIdentifier;
    
    CNcdQuery* iConfQuery;
    RPointerArray<CNcdQuery> iSubOpQuerys;
       
    MNcdParserConfigurationProtocolObserver*	iDefaultConfigurationProtocolObserver;
    
    HBufC* iServerUri;
    
    CBufFlat* iConfigResponseBuf;
        
    TBool iNodeDbLocked;
        
    /**
     * Maps of current children and their children for new checking.
     */
    RPointerArray<CNcdChildEntityMap> iChildEntityMaps;
    
    MNcdOperationQueue& iOperationQueue;
    
    TBool iFirstConfRequest;

    };

#endif // C_NCDLOADBUNDLENODEOPERATIONIMPL_H