//-------------------------------------------------------------------------------------------------------
// Project: NodeActiveX
// Author: Yuri Dursin
// Description: DispObject class declarations. This class incapsulates COM IDispatch interface to Node JS Object
//-------------------------------------------------------------------------------------------------------

#pragma once

#include "utils.h"

enum options_t { 
    option_none = 0, 
    option_async = 0x0001, 
    option_type = 0x0002,
    option_activate = 0x0004,
    option_prepared = 0x0100,
    option_owned = 0x0200,
    option_property = 0x0400,
    option_function_simple = 0x0800,
    option_mask = 0x00FF,
    option_auto = (option_async | option_type)
};

inline bool TypeInfoGetName(ITypeInfo *info, DISPID dispid, BSTR *name) {
    HRESULT hrcode = info->GetDocumentation(dispid, name, NULL, NULL, NULL);
    if SUCCEEDED(hrcode) return true;
    UINT cnt_ret;
    return info->GetNames(dispid, name, 1, &cnt_ret) == S_OK && cnt_ret > 0;
}

template<typename T>
bool TypeInfoPrepareFunc(ITypeInfo *info, UINT n, T process) {
    FUNCDESC *desc;
    if (info->GetFuncDesc(n, &desc) != S_OK) return false;
    process(info, desc, nullptr);
    info->ReleaseFuncDesc(desc);
    return true;
}

template<typename T>
bool TypeInfoPrepareVar(ITypeInfo *info, UINT n, T process) {
    VARDESC *desc;
    if (info->GetVarDesc(n, &desc) != S_OK) return false;
    process(info, nullptr, desc);
    info->ReleaseVarDesc(desc);
    return true;
}

template<typename T>
void TypeInfoPrepare(ITypeInfo *info, int mode, T process) {
    UINT cFuncs = 0, cVars = 0;
    TYPEATTR *pattr = NULL;
    if (info->GetTypeAttr(&pattr) == S_OK) {
        cFuncs = pattr->cFuncs;
        cVars = pattr->cVars;
        info->ReleaseTypeAttr(pattr);
    }
    if ((mode & 1) != 0) {
        for (UINT n = 0; n < cFuncs; n++) {
            TypeInfoPrepareFunc<T>(info, n, process);
        }
    }
    if ((mode & 2) != 0) {
        for (UINT n = 0; n < cVars; n++) {
            TypeInfoPrepareVar<T>(info, n, process);
        }
    }
}

template<typename T>
bool TypeLibEnumerate(ITypeLib *typelib, int mode, T process) {
    UINT i, cnt = typelib ? typelib->GetTypeInfoCount() : 0;
    for (i = 0; i < cnt; i++) {
        CComPtr<ITypeInfo> info;
        if (typelib->GetTypeInfo(i, &info) != S_OK) continue;
        TypeInfoPrepare<T>(info, mode, process);
    }
    return cnt > 0;
}

class DispInfo {
public:
    std::weak_ptr<DispInfo> parent;
    CComPtr<IDispatch> ptr;
    std::wstring name;
    int options;
    bool bManaged;

    struct type_t { 
        DISPID dispid; 
        int kind; 
        int argcnt_get; 
        inline type_t(DISPID dispid_, int kind_) : dispid(dispid_), kind(kind_), argcnt_get(0) {}
        inline bool is_property() const { return ((kind & INVOKE_FUNC) == 0); }
        inline bool is_property_simple() const { return (((kind & (INVOKE_PROPERTYGET | INVOKE_FUNC))) == INVOKE_PROPERTYGET) && (argcnt_get == 0); }
        inline bool is_function_simple() const { return (((kind & (INVOKE_PROPERTYGET | INVOKE_FUNC))) == INVOKE_FUNC) && (argcnt_get == 0); }
        inline bool is_property_advanced() const { return kind == (INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT) && (argcnt_get == 1); }
    };
    typedef std::shared_ptr<type_t> type_ptr;
    typedef std::map<DISPID, type_ptr> types_by_dispid_t;
    types_by_dispid_t types_by_dispid;

    inline DispInfo(IDispatch *disp, const std::wstring &nm, int opt, std::shared_ptr<DispInfo> *parnt = nullptr)
        : ptr(disp), options(opt), name(nm), bManaged(false)
    { 
        if (parnt) parent = *parnt;
        if ((options & option_type) != 0)
            Prepare(disp);
    }

    void Prepare(IDispatch *disp) {
        Enumerate(1/*functions only*/, &bManaged, [this](ITypeInfo *info, FUNCDESC *func, VARDESC *var) {
            type_ptr &ptr = this->types_by_dispid[func->memid];
            if (!ptr) ptr.reset(new type_t(func->memid, func->invkind));
            else ptr->kind |= func->invkind;
            if ((func->invkind & INVOKE_PROPERTYGET) != 0) {
                if (func->cParams > ptr->argcnt_get)
                    ptr->argcnt_get = func->cParams;
            }
        });
        bool prepared = types_by_dispid.size() > 3; // QueryInterface, AddRef, Release
        if (prepared) options |= option_prepared;
    }

    inline bool GetTypeInfo(const DISPID dispid, type_ptr &info) {
        if ((options & option_prepared) == 0) return false;
        types_by_dispid_t::const_iterator it = types_by_dispid.find(dispid);
        if (it == types_by_dispid.end()) return false;
        info = it->second;
        return true;
    }

    HRESULT FindProperty(LPOLESTR name, DISPID *dispid) {
        return DispFind(ptr, name, dispid);
    }

    HRESULT GetProperty(DISPID dispid, LONG argcnt, VARIANT *args, VARIANT *value, EXCEPINFO *except = 0) {
        HRESULT hrcode = DispInvoke(ptr, dispid, argcnt, args, value, DISPATCH_PROPERTYGET, except);
        return hrcode;
    }

    HRESULT GetProperty(DISPID dispid, LONG index, VARIANT *value, EXCEPINFO *except = 0) {
        CComVariant arg(index);
        LONG argcnt = (index >= 0) ? 1 : 0;
        return DispInvoke(ptr, dispid, argcnt, &arg, value, DISPATCH_PROPERTYGET, except);
    }

    HRESULT SetProperty(DISPID dispid, LONG argcnt, VARIANT *args, VARIANT *value, EXCEPINFO *except = 0) {
        HRESULT hrcode = DispInvoke(ptr, dispid, argcnt, args, value, DISPATCH_PROPERTYPUT, except);
        if FAILED(hrcode) value->vt = VT_EMPTY;
        return hrcode;
    }

    HRESULT ExecuteMethod(DISPID dispid, LONG argcnt, VARIANT *args, VARIANT *value, EXCEPINFO *except = 0) {
        HRESULT hrcode = DispInvoke(ptr, dispid, argcnt, args, value, DISPATCH_METHOD, except);
        return hrcode;
    }

    template<typename T>
    bool Enumerate(int mode, bool* checkManaged, T process = nullptr) {
        UINT i, cnt;
        CComPtr<ITypeLib> prevtypelib;
        if (!ptr || FAILED(ptr->GetTypeInfoCount(&cnt))) cnt = 0;
        else for (i = 0; i < cnt; i++) {
            CComPtr<ITypeInfo> info;
            if (ptr->GetTypeInfo(i, 0, &info) != S_OK) continue;

            // Query type library
            UINT typeindex;
            CComPtr<ITypeLib> typelib;
            if (info->GetContainingTypeLib(&typelib, &typeindex) == S_OK) {

                // Check if typelib is managed
                if (checkManaged != nullptr && !*checkManaged) {
                    CComPtr<ITypeLib2> typeLib2;
                    if (SUCCEEDED(typelib->QueryInterface(IID_ITypeLib2, (void**)&typeLib2))) {

                        // {90883F05-3D28-11D2-8F17-00A0C9A6186D}
                        static const GUID GUID_ExportedFromComPlus = { 0x90883F05, 0x3D28, 0x11D2, { 0x8F, 0x17, 0x00, 0xA0, 0xC9, 0xA6, 0x18, 0x6D } };

                        CComVariant cv;
                        if (SUCCEEDED(typeLib2->GetCustData(GUID_ExportedFromComPlus, &cv))) {
                            *checkManaged = true;
                        }
                    }
                }

                // Enumerate all types in library types
                // May be very slow! need a special method
                // if (typelib != prevtypelib) {
                //     TypeLibEnumerate<T>(typelib, mode, process);
                //	   prevtypelib.Attach(typelib.Detach());
                // }

                CComPtr<ITypeInfo> tinfo;
                if (typelib->GetTypeInfo(typeindex, &tinfo) == S_OK) {
                    TypeInfoPrepare<T>(tinfo, mode, process);
                }
            }

            // Process types
            else {
                TypeInfoPrepare<T>(info, mode, process);
            }
        }
        return cnt > 0;
    }
};

typedef std::shared_ptr<DispInfo> DispInfoPtr;

class DispObject: public NodeObject
{
public:
    DispObject(const DispInfoPtr &ptr, const std::wstring &name, DISPID id = DISPID_UNKNOWN, LONG indx = -1, int opt = 0);
    ~DispObject();

    static Persistent<ObjectTemplate> inst_template;
    static Persistent<FunctionTemplate> clazz_template;
    static NodeMethods clazz_methods;

    static void NodeInit(const Local<Object> &target, Isolate* isolate, Local<Context> &ctx);
    static bool HasInstance(Isolate *isolate, const Local<Value> &obj) {
        Local<FunctionTemplate> clazz = clazz_template.Get(isolate);
        return !clazz.IsEmpty() && clazz->HasInstance(obj);
    }
    static DispObject *GetPtr(Isolate *isolate, const Local<Object> &obj) {
        Local<FunctionTemplate> clazz = clazz_template.Get(isolate);
        if (clazz.IsEmpty() || !clazz->HasInstance(obj)) return nullptr;
        return Unwrap<DispObject>(obj);
    }
    static IDispatch *GetDispPtr(Isolate *isolate, const Local<Object> &obj) {
        DispObject *self = GetPtr(isolate, obj);
        return (self && self->disp) ? self->disp->ptr : nullptr;
    }
    static bool GetValueOf(Isolate *isolate, const Local<Object> &obj, VARIANT &value) {
        DispObject *self = GetPtr(isolate, obj);
        return self && SUCCEEDED(self->valueOf(isolate, value, false));
    }
    static Local<Object> NodeCreate(Isolate *isolate, IDispatch *disp, const std::wstring &name, int opt) {
        Local<Object> parent;
        DispInfoPtr ptr(new DispInfo(disp, name, opt));
        return DispObject::NodeCreate(isolate, parent, ptr, name);
    }

private:
    static Local<Object> NodeCreate(Isolate *isolate, const Local<Object> &parent, const DispInfoPtr &ptr, const std::wstring &name, DISPID id = DISPID_UNKNOWN, LONG indx = -1, int opt = 0);

    static void NodeCreate(const FunctionCallbackInfo<Value> &args);
    static void NodeValueOf(const FunctionCallbackInfo<Value> &args);
    static void NodeToString(const FunctionCallbackInfo<Value> &args);
    static void NodeRelease(const FunctionCallbackInfo<Value> &args);
    static void NodeCast(const FunctionCallbackInfo<Value> &args);
    static void NodeGet(Local<Name> name, const PropertyCallbackInfoGetter &args);
    static void NodeSet(Local<Name> name, Local<Value> value, const PropertyCallbackInfoSetter &args);
    static void NodeGetByIndex(uint32_t index, const PropertyCallbackInfoGetter&args);
    static void NodeSetByIndex(uint32_t index, Local<Value> value, const PropertyCallbackInfoSetter &args);
    static void NodeCall(const FunctionCallbackInfo<Value> &args);

#ifdef NODE_INTERCEPTED
    static inline Intercepted InterceptedNodeGet(Local<Name> name, const PropertyCallbackInfoGetter& args) {
        NodeGet(name, args);
        return Intercepted::kYes;
    }
    static inline Intercepted InterceptedNodeSet(Local<Name> name, Local<Value> value, const PropertyCallbackInfoSetter& args) {
        NodeSet(name, value, args);
        return Intercepted::kYes;
    }
    static inline Intercepted InterceptedNodeGetByIndex(uint32_t index, const PropertyCallbackInfoGetter& args) {
        NodeGetByIndex(index, args);
        return Intercepted::kYes;
    }
    static inline Intercepted InterceptedNodeSetByIndex(uint32_t index, Local<Value> value, const PropertyCallbackInfoSetter& args) {
        NodeSetByIndex(index, value, args);
        return Intercepted::kYes;
    }
#endif

    static void NodeConnectionPoints(const FunctionCallbackInfo<Value> &args);
    static void PeakAndDispatchMessages(const FunctionCallbackInfo<Value> &args);

protected:
    bool release();
    bool get(LPOLESTR tag, LONG index, const PropertyCallbackInfoGetter &args);
    bool set(LPOLESTR tag, LONG index, const Local<Value> &value, const PropertyCallbackInfoSetter &args);
    void call(Isolate *isolate, const FunctionCallbackInfo<Value> &args);

    HRESULT valueOf(Isolate *isolate, VARIANT &value, bool simple);
    HRESULT valueOf(Isolate *isolate, const Local<Object> &self, Local<Value> &value);
    void toString(const FunctionCallbackInfo<Value> &args);
    Local<Value> getIdentity(Isolate *isolate);

private:
    int options;
    inline bool is_null() { return !disp; }
    inline bool is_prepared() { return (options & option_prepared) != 0; }
    inline bool is_object() { return dispid == DISPID_VALUE /*&& index < 0*/; }
    inline bool is_owned() { return (options & option_owned) != 0; }

    Persistent<Value> items, methods, vars;
    void initTypeInfo(Isolate *isolate);

    DispInfoPtr disp;
    std::wstring name;
    DISPID dispid;
    LONG index;

    HRESULT prepare();
};

class VariantObject : public NodeObject
{
public:
    VariantObject() {};
    VariantObject(const VARIANT &v) : value(v) {};
    VariantObject(const FunctionCallbackInfo<Value> &args);

    static Persistent<ObjectTemplate> inst_template;
    static Persistent<FunctionTemplate> clazz_template;
    static NodeMethods clazz_methods;

    static void NodeInit(const Local<Object> &target, Isolate* isolate, Local<Context> &ctx);
    static bool HasInstance(Isolate *isolate, const Local<Value> &obj) {
        Local<FunctionTemplate> clazz = clazz_template.Get(isolate);
        return !clazz.IsEmpty() && clazz->HasInstance(obj);
    }
    static VariantObject *GetInstanceOf(Isolate *isolate, const Local<Object> &obj) {
        Local<FunctionTemplate> clazz = clazz_template.Get(isolate);
        if (clazz.IsEmpty() || !clazz->HasInstance(obj)) return nullptr;
        return Unwrap<VariantObject>(obj);
    }
    static bool GetValueOf(Isolate *isolate, const Local<Object> &obj, VARIANT &value) {
        Local<FunctionTemplate> clazz = clazz_template.Get(isolate);
        if (clazz.IsEmpty() || !clazz->HasInstance(obj)) return false;
        VariantObject *self = Unwrap<VariantObject>(obj);
        return self && SUCCEEDED(self->value.CopyTo(&value));
    }

    static Local<Object> NodeCreateInstance(const FunctionCallbackInfo<Value> &args);
    static void NodeCreate(const FunctionCallbackInfo<Value> &args);
    static Local<Object> NodeCreate(Isolate* isolate, const VARIANT& var);

    static void NodeClear(const FunctionCallbackInfo<Value> &args);
    static void NodeAssign(const FunctionCallbackInfo<Value> &args);
    static void NodeCast(const FunctionCallbackInfo<Value> &args);
    static void NodeValueOf(const FunctionCallbackInfo<Value> &args);
    static void NodeToString(const FunctionCallbackInfo<Value> &args);
    static void NodeGet(Local<Name> name, const PropertyCallbackInfoGetter &args);
    static void NodeSet(Local<Name> name, Local<Value> value, const PropertyCallbackInfoSetter&args);
    static void NodeGetByIndex(uint32_t index, const PropertyCallbackInfoGetter&args);
    static void NodeSetByIndex(uint32_t index, Local<Value> value, const PropertyCallbackInfoSetter&args);

#ifdef NODE_INTERCEPTED
    static inline Intercepted InterceptedNodeGet(Local<Name> name, const PropertyCallbackInfoGetter& args) {
        NodeGet(name, args);
        return Intercepted::kYes;
    }
    static inline Intercepted InterceptedNodeSet(Local<Name> name, Local<Value> value, const PropertyCallbackInfoSetter& args) {
        NodeSet(name, value, args);
        return Intercepted::kYes;
    }
    static inline Intercepted InterceptedNodeGetByIndex(uint32_t index, const PropertyCallbackInfoGetter& args) {
        NodeGetByIndex(index, args);
        return Intercepted::kYes;
    }
    static inline Intercepted InterceptedNodeSetByIndex(uint32_t index, Local<Value> value, const PropertyCallbackInfoSetter& args) {
        NodeSetByIndex(index, value, args);
        return Intercepted::kYes;
    }
#endif

private:
    CComVariant value, pvalue;
    bool assign(Isolate *isolate, Local<Value> &val, Local<Value> &type);
};

class ConnectionPointObject : public NodeObject
{
public:
    ConnectionPointObject(IConnectionPoint *p, IDispatch* d);
    ConnectionPointObject(const FunctionCallbackInfo<Value> &args) {}
    static Persistent<ObjectTemplate> inst_template;
    static Persistent<FunctionTemplate> clazz_template;
    static Local<Object> NodeCreateInstance(Isolate *isolate, IConnectionPoint *p, IDispatch* d);
    static void NodeInit(const Local<Object> &target, Isolate* isolate, Local<Context> &ctx);
    static void NodeCreate(const FunctionCallbackInfo<Value> &args);
    static void NodeAdvise(const FunctionCallbackInfo<Value> &args);
    static void NodeUnadvise(const FunctionCallbackInfo<Value> &args);
    static void NodeConnectionPointMethods(const FunctionCallbackInfo<Value> &args);

private:
    bool InitIndex();

    CComPtr<IConnectionPoint> ptr;
    CComPtr<IDispatch> disp;
    DispObjectImpl::index_t index;

    std::unordered_set<DWORD> cookies;

};