//%LICENSE////////////////////////////////////////////////////////////////
//
// Licensed to The Open Group (TOG) under one or more contributor license
// agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
// this work for additional information regarding copyright ownership.
// Each contributor licenses this file to you under the OpenPegasus Open
// Source License; you may not use this file except in compliance with the
// License.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//////////////////////////////////////////////////////////////////////////
//
//%/////////////////////////////////////////////////////////////////////////////

#ifndef Pegasus_CMPIProviderManager_h
#define Pegasus_CMPIProviderManager_h

#include <Pegasus/Common/Config.h>
#include <Pegasus/Common/HashTable.h>
#include <Pegasus/ProviderManager2/ProviderName.h>
#include <Pegasus/ProviderManager2/ProviderManager.h>
#include <Pegasus/Common/OperationContextInternal.h>

#include <Pegasus/Config/ConfigManager.h>
#include <Pegasus/ProviderManager2/OperationResponseHandler.h>

#include <Pegasus/ProviderManager2/CMPI/CMPILocalProviderManager.h>
#include <Pegasus/ProviderManager2/CMPI/Linkage.h>
#include <Pegasus/ProviderManager2/CMPI/CMPI_ContextArgs.h>
#include <Pegasus/ProviderManager2/CMPI/CMPI_Error.h>
#include <Pegasus/ProviderManager2/CMPI/CMPI_SelectExp.h>

#include <Pegasus/Provider/CIMOMHandleQueryContext.h>
PEGASUS_NAMESPACE_BEGIN

/**
    This record is created for each indication provider to keep track of
    CMPI_SelectExp objects they are servicing.
*/
class PEGASUS_CMPIPM_LINKAGE IndProvRecord
{
public:
    IndProvRecord() : _handler(0), selectExpTab(4)
    {
    }

    ~IndProvRecord()    
    {
        CMPI_SelectExp *eSelx = 0;
        for (SelectExpTab::Iterator i = selectExpTab.start(); i; i++)
        {
            selectExpTab.lookup(i.key(), eSelx);
            delete eSelx;
        }
        delete _handler;
    }

#ifdef PEGASUS_ENABLE_REMOTE_CMPI
    void setRemoteInfo(const String &remoteInfo)
    {
        _remoteInfo = remoteInfo;
    }

    String getRemoteInfo()
    {
        return _remoteInfo;
    }
#endif

    void setHandler(EnableIndicationsResponseHandler *handler)
    {
        _handler = handler;
    }

    EnableIndicationsResponseHandler* getHandler()
    {
        return _handler;
    }

    Boolean isEnabled()
    {
        return _handler != 0;
    }

    Boolean getSelectExpCount()
    {
        return selectExpTab.size();
    }

    Boolean lookupSelectExp(
        const CIMObjectPath &path,
        CMPI_SelectExp *&eSelx)
    {
        return selectExpTab.lookup(path, eSelx);
    }

    Boolean addSelectExp(
        const CIMObjectPath &path,
        CMPI_SelectExp *eSelx)
    {
        return selectExpTab.insert(path, eSelx);
    }

    Boolean deleteSelectExp(
        const CIMObjectPath &path)
    {
        return selectExpTab.remove(path);
    }

private:
#ifdef PEGASUS_ENABLE_REMOTE_CMPI
    String _remoteInfo;
#endif
    EnableIndicationsResponseHandler* _handler;

    typedef HashTable<CIMObjectPath, CMPI_SelectExp*,
        EqualFunc<CIMObjectPath>, HashFunc<CIMObjectPath> > SelectExpTab;

    SelectExpTab selectExpTab;
};

class PEGASUS_CMPIPM_LINKAGE CMPIProviderManager : public ProviderManager
{
public:
    CMPIProviderManager();
    virtual ~CMPIProviderManager();

    virtual Message * processMessage(Message * request);

    virtual Boolean hasActiveProviders();
    virtual void unloadIdleProviders();

    virtual Boolean supportsRemoteNameSpaces()
    {
        return true;
    }

    typedef HashTable<String, IndProvRecord*,
        EqualFunc<String>,HashFunc<String> > IndProvTab;

    static IndProvTab indProvTab;
    static ReadWriteSem rwSemProvTab;
protected:
    CMPILocalProviderManager providerManager;

    void _setupCMPIContexts(
        CMPI_ContextOnStack * eCtx,
        OperationContext * context,
        const CString * nameSpace,
        const CString * remoteInfo,
        Boolean remote,
        Boolean includeQualifiers = false,
        Boolean includeClassOrigin = false,
        Boolean setFlags = false);

    CMPIProvider & _resolveAndGetProvider(
        OperationContext * context,
        OpProviderHolder * ph,
        CString * remoteInfo,
        Boolean & isRemote);

    Message * handleUnsupportedRequest(const Message * message);

    Message * handleGetInstanceRequest(const Message * message);
    Message * handleEnumerateInstancesRequest(const Message * message);
    Message * handleEnumerateInstanceNamesRequest(const Message * message);
    Message * handleCreateInstanceRequest(const Message * message);
    Message * handleModifyInstanceRequest(const Message * message);
    Message * handleDeleteInstanceRequest(const Message * message);

    Message * handleExecQueryRequest(const Message * message);

    Message * handleAssociatorsRequest(const Message * message);
    Message * handleAssociatorNamesRequest(const Message * message);
    Message * handleReferencesRequest(const Message * message);
    Message * handleReferenceNamesRequest(const Message * message);

    Message * handleGetPropertyRequest(const Message * message);
    Message * handleSetPropertyRequest(const Message * message);

    Message * handleInvokeMethodRequest(const Message * message);

    Message * handleCreateSubscriptionRequest(const Message * message);
//    Message * handleModifySubscriptionRequest(const Message * message);
    Message * handleDeleteSubscriptionRequest(const Message * message);

//  Not supported by CMPI
//    Message * handleExportIndicationRequest(const Message * message);

    Message * handleDisableModuleRequest(const Message * message);
    Message * handleEnableModuleRequest(const Message * message);
    Message * handleStopAllProvidersRequest(const Message * message);
    Message * handleSubscriptionInitCompleteRequest (const Message * message);
    Message * handleIndicationServiceDisabledRequest (Message * message);

    ProviderName _resolveProviderName(const ProviderIdContainer & providerId);

    /**
        Calls the provider's enableIndications() method, if the provider
        version supports enableIndications().

        Note that since an exception thrown by the provider's
        enableIndications() method is considered a provider error, any such
        exception is ignored, and no exceptions are thrown by this method.

        @param  req_provider  CIMInstance for the provider to be enabled
        @param  _indicationCallback  PEGASUS_INDICATION_CALLBACK_T for
            indications
        @param  ph  OpProviderHolder for the provider to be enabled
        @param remoteInfo Remote Information
     */
    void _callEnableIndications(
        CIMInstance & req_provider,
        PEGASUS_INDICATION_CALLBACK_T _indicationCallback,
        OpProviderHolder & ph,
        const char *remoteInfo);

    /**
        Calls the provider's disableIndications() method, if the provider
        version supports disableIndications().

        @param  ph  OpProviderHolder for the provider to be enabled
        @param remoteInfo Remote Information
     */
    void _callDisableIndications(
        OpProviderHolder & ph,
        const char *remoteInfo);

    String _getClassNameFromQuery(
        CIMOMHandleQueryContext *context,
        String &query,
        String &lang);

    void _throwCIMException(
        CMPIStatus code,
        CMPI_Error* cmpiError);

    SCMOInstance* getSCMOClassFromRequest(
        CString& nameSpace,
        CString& className );

    SCMOInstance* getSCMOObjectPathFromRequest(
        CString& nameSpace,
        CString& className,
        CIMObjectPath& cimObjPath );
    
    SCMOInstance* getSCMOInstanceFromRequest(
        CString& nameSpace,
        CString& className,
        CIMInstance& cimInstance );

};

PEGASUS_NAMESPACE_END

#endif

