#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);
            }
        }
    }