/*
 * WbemServices.h 
 * Copyright (c) 2012 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// 2010/03/14
// 2010/05/10 Modified the default value of the second paramete for execQuery( 
//     to be           ,
//            __in long lFlags=WBEM_FLAG_FORWARD_ONLY,    
//            
// 2012/03/08 Updated.

#pragma once

#include <sol/com/ComIUnknown.h>
#include <objbase.h>

#include <sol/COMTypeConverter.h>
#include <sol/Writer.h>
#include <sol/FileWriter.h>
#include <sol/ConsoleWriter.h>

#include <sol/LocalDateTime.h>
#include <sol/HTMLEncoder.h>

#include <wbemidl.h>
#include <wbemdisp.h>

#pragma comment(lib, "wbemuuid.lib")

#pragma comment(lib, "oleaut32.lib")


namespace SOL {

class WbemServices : public ComIUnknown {
private:
    const BSTR strQueryLanguage;
public:
    WbemServices(IWbemServices* services)
    :ComIUnknown(services),
    strQueryLanguage(L"WQL")
    {

    }        

public:
    ~WbemServices()
    {
    }

public:
    IWbemServices* getServices()
    {
        return (IWbemServices*)getIUnknown();
    }

public:
    HRESULT openNamespace( 
            __in const BSTR strNamespace,
            __in long lFlags,
            __in IWbemContext *pCtx,
            __out IWbemServices **ppWorkingNamespace,
            __out IWbemCallResult **ppResult)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> OpenNamespace( 
                strNamespace,
                lFlags,
                pCtx,
                ppWorkingNamespace,
                ppResult)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }
    }

public:
    HRESULT cancelAsyncCall( 
            __in IWbemObjectSink *pSink)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> CancelAsyncCall( 
                pSink)    )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }
    }

public:
    IWbemObjectSink* queryObjectSink( 
            __in long lFlags)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        IWbemObjectSink *pResponseHandler = NULL;
        if (FAILED(hr = services -> QueryObjectSink( 
                lFlags,
                &pResponseHandler)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return pResponseHandler;
        }
    }

public:
    HRESULT getObject( 
            __in const BSTR strObjectPath,
            __in long lFlags,
            __in IWbemContext *pCtx,
            __out IWbemClassObject **ppObject,
            __out IWbemCallResult **ppCallResult)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> GetObject( 
                strObjectPath,
                lFlags,
                pCtx,
                ppObject,
                ppCallResult)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }

    }

public:
    HRESULT getObjectAsync( 
            __in const BSTR strObjectPath,
            __in long lFlags,
            __in IWbemContext *pCtx,
            __in IWbemObjectSink *pResponseHandler)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> GetObjectAsync( 
                strObjectPath,
                lFlags,
                pCtx,
                pResponseHandler)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }
    }

public:
    IWbemCallResult* putClass( 
            __in IWbemClassObject *pObject,
            __in long lFlags,
            __in IWbemContext *pCtx)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        IWbemCallResult *pCallResult = NULL;
        if (FAILED(hr = services -> PutClass( 
                pObject,
                lFlags,
                pCtx,
                &pCallResult)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return pCallResult;
        }
    }


public:
    HRESULT putClassAsync( 
            __in IWbemClassObject *pObject,
            __in long lFlags,
            __in IWbemContext *pCtx,
            __in IWbemObjectSink *pResponseHandler)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> PutClassAsync( 
                pObject,
                lFlags,
                pCtx,
                pResponseHandler)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }
    }

public:
    IWbemCallResult* deleteClass( 
            __in const BSTR strClass,
            __in long lFlags,
            __in IWbemContext *pCtx)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        IWbemCallResult *pCallResult = NULL;
        if (FAILED(hr = services -> DeleteClass( 
                strClass,
                lFlags,
                pCtx,
                &pCallResult)  )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return pCallResult;
        }
    }

public:
    HRESULT deleteClassAsync( 
            __in const BSTR strClass,
            __in long lFlags,
            __in IWbemContext *pCtx,
            __in IWbemObjectSink *pResponseHandler)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> DeleteClassAsync( 
                strClass,
                lFlags,
                pCtx,
                pResponseHandler)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }
    }

public:
    IEnumWbemClassObject* createClassEnum( 
            __in const BSTR strSuperclass,
            __in long lFlags,
            __in IWbemContext *pCtx
            )
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        IEnumWbemClassObject *pEnum = NULL;
        if (FAILED(hr = services -> CreateClassEnum( 
                strSuperclass,
                lFlags,
                pCtx,
                &pEnum)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return pEnum;
        }
    }

public:
    HRESULT createClassEnumAsync( 
            __in const BSTR strSuperclass,
            __in long lFlags,
            __in IWbemContext *pCtx,
            __in IWbemObjectSink *pResponseHandler)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> CreateClassEnumAsync( 
                strSuperclass,
                lFlags,
                pCtx,
                pResponseHandler)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }
    }

public:
    IWbemCallResult* putInstance( 
            __in IWbemClassObject *pInst,
            __in long lFlags,
            __in IWbemContext *pCtx)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        IWbemCallResult *pCallResult = NULL;
        if (FAILED(hr = services -> PutInstance( 
                pInst,
                lFlags,
                pCtx,
                &pCallResult)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return pCallResult;
        }
    }


public:
    HRESULT putInstanceAsync( 
            __in IWbemClassObject *pInst,
            __in long lFlags,
            __in IWbemContext *pCtx,
            __in IWbemObjectSink *pResponseHandler)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> PutInstanceAsync( 
                pInst,
                lFlags,
                pCtx,
                pResponseHandler)    )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }
    }

public:
    IWbemCallResult* deleteInstance( 
            __in const BSTR strObjectPath,
            __in long lFlags,
            __in IWbemContext *pCtx
            )
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        IWbemCallResult *pCallResult = NULL;
        if (FAILED(hr = services -> DeleteInstance( 
                strObjectPath,
                lFlags,
                pCtx,
                &pCallResult)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return pCallResult;
        }
    }

public:
    HRESULT deleteInstanceAsync( 
            __in const BSTR strObjectPath,
            __in long lFlags,
            __in IWbemContext *pCtx,
            __in IWbemObjectSink *pResponseHandler)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> DeleteInstanceAsync( 
                strObjectPath,
                lFlags,
                pCtx,
                pResponseHandler)    )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }
    }

public:
    IEnumWbemClassObject* createInstanceEnum( 
            __in const BSTR strFilter,
            __in long lFlags,
            __in IWbemContext *pCtx
            )
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        IEnumWbemClassObject *pEnum = NULL;
        if (FAILED(hr = services -> CreateInstanceEnum( 
                strFilter,
                lFlags,
                pCtx,
                &pEnum)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return pEnum;
        }
    }

public:
    HRESULT createInstanceEnumAsync( 
            __in const BSTR strFilter,
            __in long lFlags,
            __in IWbemContext *pCtx,
            __in IWbemObjectSink *pResponseHandler)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> CreateInstanceEnumAsync( 
                strFilter,
                lFlags,
                pCtx,
                pResponseHandler)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }
    }
public:
    IEnumWbemClassObject* execQuery( 
            __in const BSTR strQuery,
            __in long lFlags=WBEM_FLAG_FORWARD_ONLY,    //2010/05/10 |WBEM_FLAG_RETURN_IMMEDIATELY,
            __in IWbemContext *pCtx=NULL)
       
    {
        HRESULT hr = S_OK;
        IEnumWbemClassObject *pEnum = NULL;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> ExecQuery( 
                this->strQueryLanguage,
                strQuery,
                lFlags,
                pCtx,
                &pEnum)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return pEnum;
        }
    }


public:
    HRESULT execQueryAsync( 
            __in const BSTR strQuery,
            __in IWbemObjectSink *pResponseHandler,
            __in long lFlags = WBEM_FLAG_BIDIRECTIONAL,
            __in IWbemContext *pCtx =NULL)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> ExecQueryAsync( 
                this->strQueryLanguage,
                strQuery,
                lFlags,
                pCtx,
                pResponseHandler)  )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }
    }

public:
    //wbemFlagForwardOnly|wbemFlagReturnImmediately,
    IEnumWbemClassObject* execNotificationQuery( 
            __in const BSTR strQuery,
            __in long lFlags=WBEM_FLAG_FORWARD_ONLY|WBEM_FLAG_RETURN_IMMEDIATELY,
            __in IWbemContext *pCtx = NULL)
    {
        HRESULT hr = S_OK;
        IEnumWbemClassObject *pEnum = NULL;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> ExecNotificationQuery( 
                this->strQueryLanguage,
                strQuery,
                lFlags,
                pCtx,
                &pEnum)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return pEnum;
        }
    }


public:
    HRESULT execNotificationQueryAsync( 
            __in const BSTR strQuery,
            __in IWbemObjectSink *pResponseHandler,
            __in long lFlags = WBEM_FLAG_SEND_STATUS,
            __in IWbemContext *pCtx = NULL)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> ExecNotificationQueryAsync( 
                this->strQueryLanguage,
                strQuery,
                lFlags,
                pCtx,
                pResponseHandler)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }
    }

public:
    HRESULT execMethod( 
            __in const BSTR strObjectPath,
            __in const BSTR strMethodName,
            __in long lFlags,
            __in IWbemContext *pCtx,
            __in IWbemClassObject *pInParams,
            __out IWbemClassObject **ppOutParams,
            __out IWbemCallResult **ppCallResult)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> ExecMethod( 
                strObjectPath,
                strMethodName,
                lFlags,
                pCtx,
                pInParams,
                ppOutParams,
                ppCallResult)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }
    }

public:
    HRESULT execMethodAsync( 
            __in const BSTR strObjectPath,
            __in const BSTR strMethodName,
            __in long lFlags,
            __in IWbemContext *pCtx,
            __in IWbemClassObject *pInParams,
            __in IWbemObjectSink *pResponseHandler)
    {
        HRESULT hr = S_OK;
        IWbemServices* services = getServices();
        if (FAILED(hr = services -> ExecMethodAsync( 
                strObjectPath,
                strMethodName,
                lFlags,
                pCtx,
                pInParams,
                pResponseHandler)   )) {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL",__FUNCTION__);
        }
        else {
            return hr;
        }
    }

};
    
}