#include <windows.h>
#include <iostream>


//COM sample

class ICallback : public IUnknown
{
public:
    virtual HRESULT __stdcall execute() = 0;
    virtual HRESULT __stdcall dispatch(ICallback* other) = 0;
};


extern "C"  __declspec(dllexport) ICallback* __stdcall UnmanagedWrapCallback(ICallback* cb);

// {FFB46654-083E-486A-94B8-E28B5C01561D}
static const GUID IID_ICallback =
{ 0xffb46654, 0x83e, 0x486a,{ 0x94, 0xb8, 0xe2, 0x8b, 0x5c, 0x1, 0x56, 0x1d } };


class UnmanagedCallback : public ICallback
{
    ULONG _refCount;
    ICallback* _other;
public:
    UnmanagedCallback(ICallback* other) : _refCount(1), _other(other)
    {
        std::cout << "ctor UnmanagedCallback" << std::endl;
        _other->AddRef();
    }

    ~UnmanagedCallback()
    {
        std::cout << "dtor UnmanagedCallback" << std::endl;
        _other->Release();
    }

    //IUnknown
    HRESULT __stdcall QueryInterface(REFIID riid, void ** ppvObject) override
    {
        OLECHAR* strGuid;
        StringFromCLSID(riid, &strGuid);
        std::wcout << L"UnmanagedCallback.QueryInterface. Requested IID: " << strGuid << std::endl;
        CoTaskMemFree(strGuid);
            
        if (ppvObject == nullptr) return E_INVALIDARG;

        if (riid == IID_IUnknown)
        {
            *ppvObject = static_cast<IUnknown*>(this);
            AddRef();
            return S_OK;
        }
        else if (riid == IID_ICallback)
        {
            *ppvObject = static_cast<ICallback*>(this);
            AddRef();
            return S_OK;
        }

        *ppvObject = nullptr;

        return E_NOINTERFACE;
    }

    ULONG __stdcall AddRef(void) override
    {
        std::cout << "UnmanagedCallback.AddRef" << std::endl;
        auto cnt = ++_refCount;
        return cnt;
    }

    ULONG __stdcall Release(void) override
    {
        std::cout << "UnmanagedCallback.Release" << std::endl;
        auto cnt = --_refCount;
        if (cnt == 0)
        {
            delete this;
        }
        return cnt;
    }

    //ICallback

    HRESULT __stdcall execute() override
    {
        std::cout << "UnmanagedCallback.execute" << std::endl;
        _other->execute();
        return S_OK;
    }

    HRESULT __stdcall dispatch(ICallback* other) override
    {
        std::cout << "UnmanagedCallback.dispatch" << std::endl;
        if (other == nullptr) return E_INVALIDARG;

        _other->dispatch(other);

        return S_OK;
    }
};


extern "C" __declspec(dllexport) ICallback* __stdcall UnmanagedWrapCallback(ICallback* other)
{
    auto ucb = new UnmanagedCallback(other);
    return ucb;
}

    class Program
    {
        #region COM interop

        [ComVisible(true), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
        [Guid("FFB46654-083E-486A-94B8-E28B5C01561D")]
        public interface ICallback
        {
            void Execute();

            void Dispatch(ICallback other);
        }

        public class ManagedCallback : ICallback
        {
            public void Execute()
            {
                Console.WriteLine($"{nameof(ManagedCallback)}.{nameof(Execute)}");
            }

            public void Dispatch(ICallback other)
            {
                Console.WriteLine($"{nameof(ManagedCallback)}.{nameof(Dispatch)}");
                other.Execute();
            }
        }

        [DllImport("Win32Project1.dll", CallingConvention = CallingConvention.StdCall)]
        private static extern ICallback UnmanagedWrapCallback(ICallback cb);

        #endregion COM interop


        static void Main()
        {
            Console.WriteLine("Press Enter key to continue...");
            //Console.ReadLine();

            TestComCallback();
        }

        static void TestComCallback()
        {
            var mcb = new ManagedCallback();
            mcb.Execute();

            WrapUnmanaged(mcb);
        }

        static void WrapUnmanaged(ICallback cb)
        {
            var ucb = UnmanagedWrapCallback(cb);

            try
            {
                ucb.Execute();
                ucb.Dispatch(cb);
            }
            finally
            {
                Marshal.ReleaseComObject(ucb);
            }
        }
    }

#include <stdio.h>
#include <cassert>


class ICallbackNotCom
{
public:
    virtual bool __stdcall release() = 0;
    virtual bool __stdcall execute() = 0;
    virtual bool __stdcall dispatch(ICallbackNotCom* other) = 0;
};

static void trace(const char* message)
{
    fprintf(stderr, "%s\n", message);
    //std::cout << message << std::endl;
}

class UnmanagedCallbackNotCom : public ICallbackNotCom
{
    static constexpr const char* Signature = "INTEROP";

    ICallbackNotCom* _other;
    const char* _sig;

private:
    void CheckSignature() const
    {
        assert(_sig == Signature);
    }

public:
    UnmanagedCallbackNotCom(ICallbackNotCom* other) : _other(other)
    {
        trace("ctor UnmanagedCallbackNotCom");
        _sig = Signature;
    }

    ~UnmanagedCallbackNotCom()
    {
        CheckSignature();
        trace("dtor UnmanagedCallbackNotCom");
    }


    //ICallbackNotCom

    bool __stdcall release() override
    {
        CheckSignature();
        trace("UnmanagedCallbackNotCom.release");
        delete this;
        return true;
    }

    bool __stdcall execute() override
    {
        CheckSignature();
        trace("UnmanagedCallbackNotCom.execute");
        _other->execute();
        return true;
    }

    bool __stdcall dispatch(ICallbackNotCom* other) override
    {
        CheckSignature();
        trace("UnmanagedCallbackNotCom.dispatch");
        if (other == nullptr) return false;

        _other->dispatch(other);

        return true;
    }
};

extern "C" __declspec(dllexport) ICallbackNotCom* __stdcall UnmanagedWrapCallbackNotCom(ICallbackNotCom* other)
{
    auto ucb = new UnmanagedCallbackNotCom(other);
    return ucb;
}

    class Program
    {
        public interface ICallback
        {
            void Execute();

            void Dispatch(ICallback other);
        }

        public class ManagedCallback : ICallback
        {
            public void Execute()
            {
                Console.WriteLine($"{nameof(ManagedCallback)}.{nameof(Execute)}");
            }

            public void Dispatch(ICallback other)
            {
                Console.WriteLine($"{nameof(ManagedCallback)}.{nameof(Dispatch)}");
                other.Execute();
            }
        }

        [StructLayout(LayoutKind.Sequential)]
        public class NativeCallbackShim
        {
            [StructLayout(LayoutKind.Sequential)]
            public sealed class Vtbl
            {
                [UnmanagedFunctionPointer(CallingConvention.StdCall)]
                public delegate bool ReleaseHandler(IntPtr self);

                [UnmanagedFunctionPointer(CallingConvention.StdCall)]
                public delegate bool ExecuteHandler(IntPtr self);

                [UnmanagedFunctionPointer(CallingConvention.StdCall)]
                public delegate bool DispatchHandler(IntPtr self, IntPtr other);

                //GCC (Itanium ABI) specific
                //public IntPtr VTableEntry0;
                //public IntPtr VTableEntry1;

                public ReleaseHandler Release;
                public ExecuteHandler Execute;
                public DispatchHandler Dispatch;
            }

            protected IntPtr _vtblPtr;

            protected NativeCallbackShim()
            {
            }

            public NativeCallbackShim(IntPtr thisPtr)
            {
                var iface = Marshal.PtrToStructure<NativeCallbackShim>(thisPtr);
                _vtblPtr = iface._vtblPtr;
            }

            public static Vtbl GetVtbl(IntPtr thisPtr)
            {
                var iface = Marshal.PtrToStructure<NativeCallbackShim>(thisPtr);
                var vtbl = iface.GetVtbl();
                return vtbl;
            }

            public Vtbl GetVtbl() => Marshal.PtrToStructure<Vtbl>(_vtblPtr);
        }

        public sealed class NativeCallback : ICallback, IDisposable
        {
            private IntPtr _nativeCallbackPtr;
            private readonly NativeCallbackShim.Vtbl _vtbl;

            public NativeCallback(IntPtr callbackPtr)
            {
                _nativeCallbackPtr = callbackPtr;
                _vtbl = NativeCallbackShim.GetVtbl(callbackPtr);
            }

            public void Execute()
            {
                CheckDisposedState();
                _vtbl.Execute(_nativeCallbackPtr);
            }

            public void Dispatch(ICallback other)
            {
                CheckDisposedState();
                using (var shim = new Managed2NativeCallbackShim(other))
                {
                    _vtbl.Dispatch(_nativeCallbackPtr, shim.ToPointer());
                }
            }

            public void Dispose()
            {
                if (_nativeCallbackPtr != IntPtr.Zero)
                {
                    _vtbl.Release(_nativeCallbackPtr);
                    _nativeCallbackPtr = IntPtr.Zero;
                }
            }

            private void CheckDisposedState()
            {
                if (_nativeCallbackPtr == IntPtr.Zero)
                {
                    throw new ObjectDisposedException(nameof(NativeCallback));
                }
            }
        }

        [StructLayout(LayoutKind.Sequential)]
        public sealed class Managed2NativeCallbackShim : NativeCallbackShim, ICallback, IDisposable
        {
            [StructLayout(LayoutKind.Sequential)]
            private struct NativeInterfaceShim
            {
                public IntPtr vtblPtr;
            }

            private readonly Vtbl _vtbl; //note: keep reference to vtbl!
            private IntPtr _thisPtr;
            private readonly ICallback _callback;

            public Managed2NativeCallbackShim(ICallback cb)
            {
                _callback = cb;
                //note: keep reference to vtbl!
                _vtbl = new Vtbl
                {
                    Release = _ => true,
                    Execute = _ =>
                    {
                        Execute();
                        return true;
                    },
                    Dispatch = (_, other) =>
                    {
                        Dispatch(new NativeCallback(other));
                        return true;
                    }
                };

                var vtblSize = Marshal.SizeOf(_vtbl);
                _vtblPtr = Marshal.AllocHGlobal(vtblSize);
                Marshal.StructureToPtr(_vtbl, _vtblPtr, false);
            }

            public IntPtr ToPointer()
            {
                CheckDisposedState();
                if (_thisPtr == IntPtr.Zero)
                {
                    var shim = new NativeInterfaceShim { vtblPtr = _vtblPtr};
                    _thisPtr = Marshal.AllocHGlobal(Marshal.SizeOf(shim));
                    Marshal.StructureToPtr(shim, _thisPtr, false);
                }
                return _thisPtr;
            }

            public void Execute()
            {
                CheckDisposedState();
                _callback.Execute();
            }

            public void Dispatch(ICallback other)
            {
                CheckDisposedState();
                _callback.Dispatch(other);
            }

            public void Dispose()
            {
                if (_thisPtr != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(_thisPtr);
                    _thisPtr = IntPtr.Zero;
                }

                if (_vtblPtr != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(_vtblPtr);
                    _vtblPtr = IntPtr.Zero;
                }
            }

            private void CheckDisposedState()
            {
                if (_vtblPtr == IntPtr.Zero)
                {
                    throw new ObjectDisposedException(nameof(Managed2NativeCallbackShim));
                }
            }
        }

        [DllImport("Win32Project1.dll", CallingConvention = CallingConvention.StdCall)]
        static extern IntPtr UnmanagedWrapCallbackNotCom(IntPtr callback);


        static void Main()
        {
            Console.WriteLine("Press Enter key to continue...");
            //Console.ReadLine();

            TestNotComCallback();
        }


        static void TestNotComCallback()
        {
            var managedCallback = new ManagedCallback();
            var managedCallbackShim = new Managed2NativeCallbackShim(managedCallback);
            managedCallbackShim.Execute();

            var nativeCallbackPtr = UnmanagedWrapCallbackNotCom(managedCallbackShim.ToPointer());
            var nativeCallback = new NativeCallback(nativeCallbackPtr);

            try
            {
                nativeCallback.Execute();
                nativeCallback.Dispatch(managedCallbackShim);

                nativeCallback.Dispatch(nativeCallback);
            }
            finally
            {
                managedCallbackShim.Dispose();
                nativeCallback.Dispose();
            }

            GC.KeepAlive(managedCallbackShim);
        }

    }

class ICallbackNotCom
{
public:
    virtual bool __stdcall release() = 0;
    virtual bool __stdcall execute() = 0;
    virtual bool __stdcall dispatch(ICallbackNotCom* other) = 0;
};

extern "C" __declspec(dllexport) ICallbackNotCom* __stdcall UnmanagedWrapCallbackNotCom(ICallbackNotCom* other);

    public unsafe abstract partial class ICallbackNotCom : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 4)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            public global::System.IntPtr vfptr_ICallbackNotCom;

            //[SuppressUnmanagedCodeSecurity]
            //[DllImport("NotComCallback.Native.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
            //    EntryPoint="??0ICallbackNotCom@@QAE@XZ")]
            //internal static extern global::System.IntPtr ctor_0(global::System.IntPtr instance);

            //[SuppressUnmanagedCodeSecurity]
            //[DllImport("NotComCallback.Native.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
            //    EntryPoint="??0ICallbackNotCom@@QAE@ABV0@@Z")]
            //internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, ICallbackNotCom> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, ICallbackNotCom>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        public static ICallbackNotCom __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new ICallbackNotComInternal(native.ToPointer(), skipVTables);
        }

        public static ICallbackNotCom __CreateInstance(ICallbackNotCom.__Internal native, bool skipVTables = false)
        {
            return new ICallbackNotComInternal(native, skipVTables);
        }

        protected ICallbackNotCom(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
            __OriginalVTables = new void*[] { ((__Internal*) native)->vfptr_ICallbackNotCom.ToPointer() };
        }

        protected ICallbackNotCom()
        {
            __Instance = Marshal.AllocHGlobal(4);
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            //__Internal.ctor_0((__Instance + __PointerAdjustment));
            SetupVTables(GetType().FullName == "NotComCallback.ICallbackNotCom");
        }

        protected ICallbackNotCom(ICallbackNotCom _0)
        {
            __Instance = Marshal.AllocHGlobal(4);
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            if (ReferenceEquals(_0, null))
                throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
            var __arg0 = _0.__Instance;
            //__Internal.cctor_1((__Instance + __PointerAdjustment), __arg0);
            SetupVTables(GetType().FullName == "NotComCallback.ICallbackNotCom");
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            ICallbackNotCom __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            ((__Internal*) __Instance)->vfptr_ICallbackNotCom = new global::System.IntPtr(__OriginalVTables[0]);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
        }

        public abstract bool Execute();

        public abstract bool Dispatch(ICallbackNotCom other);

        public abstract bool Release
        {
            get;
        }

        #region Virtual table interop

        // bool __stdcall release() = 0
        private static Delegates.Func_bool_IntPtr _Release_0DelegateInstance;

        private static bool _Release_0DelegateHook(global::System.IntPtr instance)
        {
            if (!NativeToManagedMap.ContainsKey(instance))
                throw new global::System.Exception("No managed instance was found");

            var __target = (ICallbackNotCom) NativeToManagedMap[instance];
            if (__target.__ownsNativeInstance)
                __target.SetupVTables();
            var __ret = __target.Release;
            return __ret;
        }

        // bool __stdcall execute() = 0
        private static Delegates.Func_bool_IntPtr _Execute_0DelegateInstance;

        private static bool _Execute_0DelegateHook(global::System.IntPtr instance)
        {
            if (!NativeToManagedMap.ContainsKey(instance))
                throw new global::System.Exception("No managed instance was found");

            var __target = (ICallbackNotCom) NativeToManagedMap[instance];
            if (__target.__ownsNativeInstance)
                __target.SetupVTables();
            var __ret = __target.Execute();
            return __ret;
        }

        // bool __stdcall dispatch(ICallbackNotCom* other) = 0
        private static Delegates.Func_bool_IntPtr_IntPtr _Dispatch_0DelegateInstance;

        private static bool _Dispatch_0DelegateHook(global::System.IntPtr instance, global::System.IntPtr other)
        {
            if (!NativeToManagedMap.ContainsKey(instance))
                throw new global::System.Exception("No managed instance was found");

            var __target = (ICallbackNotCom) NativeToManagedMap[instance];
            if (__target.__ownsNativeInstance)
                __target.SetupVTables();
            ICallbackNotCom __result0;
            if (other == IntPtr.Zero) __result0 = null;
            else if (ICallbackNotCom.NativeToManagedMap.ContainsKey(other))
                __result0 = (ICallbackNotCom) ICallbackNotCom.NativeToManagedMap[other];
            else __result0 = ICallbackNotCom.__CreateInstance(other);
            var __ret = __target.Dispatch(__result0);
            return __ret;
        }

        private static void*[] __ManagedVTables;
        private static void*[] _Thunks;

        private void SetupVTables(bool destructorOnly = false)
        {
            if (__OriginalVTables != null)
                return;
            var native = (__Internal*) __Instance.ToPointer();

            __OriginalVTables = new void*[] { ((__Internal*) native)->vfptr_ICallbackNotCom.ToPointer() };

            if (destructorOnly)
                return;
            if (_Thunks == null)
            {
                _Thunks = new void*[3];
                _Release_0DelegateInstance += _Release_0DelegateHook;
                _Thunks[0] = Marshal.GetFunctionPointerForDelegate(_Release_0DelegateInstance).ToPointer();
                _Execute_0DelegateInstance += _Execute_0DelegateHook;
                _Thunks[1] = Marshal.GetFunctionPointerForDelegate(_Execute_0DelegateInstance).ToPointer();
                _Dispatch_0DelegateInstance += _Dispatch_0DelegateHook;
                _Thunks[2] = Marshal.GetFunctionPointerForDelegate(_Dispatch_0DelegateInstance).ToPointer();
            }

            if (__ManagedVTables == null)
            {
                __ManagedVTables = new void*[1];
                var vfptr0 = Marshal.AllocHGlobal(3 * 4);
                __ManagedVTables[0] = vfptr0.ToPointer();
                *(void**)(vfptr0 + 0) = _Thunks[0];
                *(void**)(vfptr0 + 4) = _Thunks[1];
                *(void**)(vfptr0 + 8) = _Thunks[2];
            }

            native->vfptr_ICallbackNotCom = new IntPtr(__ManagedVTables[0]);
        }

        #endregion
    }

    public unsafe partial class ICallbackNotComInternal : ICallbackNotCom, IDisposable
    {
        private static void* __CopyValue(ICallbackNotCom.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(4);
            *(ICallbackNotCom.__Internal*) ret = native;
            return ret.ToPointer();
        }

        internal ICallbackNotComInternal(ICallbackNotCom.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        internal ICallbackNotComInternal(void* native, bool skipVTables = false)
            : base((void*) null)
        {
            __PointerAdjustment = 0;
            __Instance = new global::System.IntPtr(native);
            __OriginalVTables = new void*[] { ((__Internal*) native)->vfptr_ICallbackNotCom.ToPointer() };
        }

        public override bool Execute()
        {
            var __slot = *(void**) ((IntPtr) __OriginalVTables[0] + 1 * 4);
            var ___Execute_0Delegate = (Delegates.Func_bool_IntPtr) Marshal.GetDelegateForFunctionPointer(new IntPtr(__slot), typeof(Delegates.Func_bool_IntPtr));
            var __ret = ___Execute_0Delegate((__Instance + __PointerAdjustment));
            return __ret;
        }

        public override bool Dispatch(ICallbackNotCom other)
        {
            var __slot = *(void**) ((IntPtr) __OriginalVTables[0] + 2 * 4);
            var ___Dispatch_0Delegate = (Delegates.Func_bool_IntPtr_IntPtr) Marshal.GetDelegateForFunctionPointer(new IntPtr(__slot), typeof(Delegates.Func_bool_IntPtr_IntPtr));
            var __arg0 = ReferenceEquals(other, null) ? global::System.IntPtr.Zero : other.__Instance;
            var __ret = ___Dispatch_0Delegate((__Instance + __PointerAdjustment), __arg0);
            return __ret;
        }

        public override bool Release
        {
            get
            {
                var __slot = *(void**) ((IntPtr) __OriginalVTables[0] + 0 * 4);
                var ___Release_0Delegate = (Delegates.Func_bool_IntPtr) Marshal.GetDelegateForFunctionPointer(new IntPtr(__slot), typeof(Delegates.Func_bool_IntPtr));
                var __ret = ___Release_0Delegate((__Instance + __PointerAdjustment));
                return __ret;
            }
        }
    }

    public unsafe partial class NotComCallback
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("NotComCallback.Native.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.StdCall,
                EntryPoint="_UnmanagedWrapCallbackNotCom@4")]
            internal static extern global::System.IntPtr UnmanagedWrapCallbackNotCom_0(global::System.IntPtr other);
        }

        public static ICallbackNotCom UnmanagedWrapCallbackNotCom(ICallbackNotCom other)
        {
            var __arg0 = ReferenceEquals(other, null) ? global::System.IntPtr.Zero : other.__Instance;
            var __ret = __Internal.UnmanagedWrapCallbackNotCom_0(__arg0);
            ICallbackNotCom __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (ICallbackNotCom.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (ICallbackNotCom) ICallbackNotCom.NativeToManagedMap[__ret];
            else __result0 = ICallbackNotCom.__CreateInstance(__ret);
            return __result0;
        }
    }

    namespace Delegates
    {
        [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointerAttribute(global::System.Runtime.InteropServices.CallingConvention.StdCall)]
        public unsafe delegate bool Func_bool_IntPtr(global::System.IntPtr instance);

        [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointerAttribute(global::System.Runtime.InteropServices.CallingConvention.StdCall)]
        public unsafe delegate bool Func_bool_IntPtr_IntPtr(global::System.IntPtr instance, global::System.IntPtr arg1);
    }