/*
 * ComIDispatch.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


//2009/12/04

#pragma once

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

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

//2009/12/22
#include <sol/LocalDateTime.h>
#include <sol/HTMLEncoder.h>

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


namespace SOL {

class ComIDispatch :public ComIUnknown {

public:
    ComIDispatch(IDispatch* pDisp=NULL)
    :ComIUnknown(pDisp)
    {

    }

public:
    ~ComIDispatch() 
    {
    }


public:
    virtual void display()
    {
        Writer console;
        write(console);
    }

public:
    virtual void write(Writer& writerr)
    {
        printf("ComIDispatch::display\n");
    }

public:
    //If needed, please redefine this method in your own sublcass;
    virtual HRESULT createInstance()
    {
        HRESULT hr = E_FAIL;
        return hr;
    }

public:
    HRESULT createInstance(__in REFCLSID rclsId,  __in REFIID riid, 
            __in_opt DWORD dwClsContext=CLSCTX_INPROC_SERVER,     
            __in_opt LPUNKNOWN pUnkOuter=NULL)
    {
        IDispatch* pDisp =NULL;

        HRESULT hr = E_FAIL;
        if (SUCCEEDED(hr = CoCreateInstance(
            rclsId,     
            pUnkOuter,            
            dwClsContext, 
            riid, 
            (void**)&pDisp))) {
            //OK. 
            set(pDisp);
        } else {
            //If failed, throw hr;
            printf("Failed to createInstance\n");
            throw hr;
        }
        return hr;
    }

public:
    IDispatch* getIDispatch()
    {
        return (IDispatch*)getIUnknown();
    }

public:
    operator IDispatch*() 
    {
        return getIDispatch();
    }


public:
    HRESULT getProperty(__in OLECHAR* ptName, __out VARIANT* pvResult) 
    {
        if (ptName == NULL || pvResult == NULL) {
            throw E_POINTER;
        }

        IDispatch* pDisp = getIDispatch();

        HRESULT hr = E_FAIL;

        DISPID dispID = 0;


        if (FAILED(hr = pDisp->GetIDsOfNames(IID_NULL, &ptName, 1, LOCALE_USER_DEFAULT, 
                                &dispID)) ) { 
            return hr; 
        }

        DISPPARAMS dispParams;
        memset(&dispParams, 0, sizeof(dispParams));

        return pDisp->Invoke(dispID, IID_NULL,
                    LOCALE_USER_DEFAULT,
                    DISPATCH_PROPERTYGET,
                    &dispParams, 
                    pvResult,
                    NULL, NULL);
    }

public:
    HRESULT putProperty(__in OLECHAR* ptName, __in const VARIANT* pvValue)
    {
        if (ptName == NULL || pvValue == NULL) {
            throw E_POINTER;
        }

        IDispatch* pDisp = getIDispatch();

        DISPID dispID = 0;
    
        HRESULT hr = E_FAIL;

          if (FAILED(hr = pDisp->GetIDsOfNames(IID_NULL, &ptName, 1, LOCALE_USER_DEFAULT, 
                &dispID)) ) {
            return hr; 
        }

        VARIANTARG vArgs[1];
        VariantInit(&vArgs[0]);
        VariantCopy(&vArgs[0], pvValue);

        DISPID dispIDNamedArgs[1] = {DISPID_PROPERTYPUT};

        DISPPARAMS dispParams;
        memset(&dispParams, 0, sizeof(dispParams));

        dispParams.rgvarg = vArgs;
        dispParams.rgdispidNamedArgs = dispIDNamedArgs;
        dispParams.cArgs = 1;
        dispParams.cNamedArgs = 1;

        hr = pDisp->Invoke(dispID, IID_NULL,
                    LOCALE_USER_DEFAULT,
                    DISPATCH_PROPERTYPUT,
                    &dispParams, NULL,
                    NULL, NULL);
        VariantClear(&vArgs[0]);

        return hr;
    }

public:
    HRESULT invoke(__in OLECHAR* method, __out VARIANT* pvResult, __in int nArgs, ...)
    {
        if (method == NULL || pvResult == NULL) {
            throw E_POINTER;
        }

        HRESULT hr = E_FAIL;

        IDispatch* pDisp = getIDispatch();
        DISPID dispID = 0;

        if (FAILED(hr = pDisp->GetIDsOfNames(IID_NULL, &method, 1, LOCALE_USER_DEFAULT, 
                &dispID)) ) {
            return hr; 
        }

        VARIANTARG *pvArgs = NULL;
        va_list ap;
    
        if(nArgs > 0){        
            pvArgs = new VARIANTARG[nArgs];
            va_start(ap, nArgs);
            for(int i=0;i<nArgs;i++){
                VariantInit(&pvArgs[i]);
                VariantCopy(&pvArgs[i], &va_arg(ap, VARIANT));
            }
            va_end(ap);
        }
    
        DISPPARAMS dispParams;
        memset(&dispParams, 0, sizeof(dispParams));

        dispParams.rgvarg =  pvArgs;
        dispParams.rgdispidNamedArgs = NULL;
        dispParams.cArgs = nArgs;
        dispParams.cNamedArgs = 0;

        hr = pDisp->Invoke(
                dispID, IID_NULL,
                LOCALE_USER_DEFAULT,
                DISPATCH_METHOD,
                &dispParams, pvResult,
                NULL, NULL);

        for(int i=0; i<nArgs; i++){
            VariantClear(&pvArgs[i]);
        }

        if(pvArgs){
            delete[] pvArgs;
        }
        return hr;
    }

};


}