internal async Task OnModuleEventMessageReceivedAsync()

in iothub/device/src/InternalClient.cs [1750:1814]
58 lines of code
12 McCabe index (conditional complexity)

        internal async Task OnModuleEventMessageReceivedAsync(string input, Message message)
        {
            if (Logging.IsEnabled)
                Logging.Enter(this, input, message, nameof(OnModuleEventMessageReceivedAsync));

            if (message == null)
            {
                return;
            }

            try
            {
                Tuple<MessageHandler, object> callback = null;
                await _moduleReceiveMessageSemaphore.WaitAsync().ConfigureAwait(false);
                try
                {
                    if (_receiveEventEndpoints == null
                        || string.IsNullOrWhiteSpace(input)
                        || !_receiveEventEndpoints.TryGetValue(input, out callback))
                    {
                        callback = _defaultEventCallback;
                    }
                }
                finally
                {
                    _moduleReceiveMessageSemaphore.Release();
                }

                MessageResponse response = MessageResponse.Completed;
                if (callback?.Item1 != null)
                {
                    response = await callback.Item1.Invoke(message, callback.Item2).ConfigureAwait(false);
                }

                if (Logging.IsEnabled)
                    Logging.Info(this, $"{nameof(MessageResponse)} = {response}", nameof(OnModuleEventMessageReceivedAsync));

                try
                {
                    switch (response)
                    {
                        case MessageResponse.Completed:
                            await CompleteAsync(message).ConfigureAwait(false);
                            break;

                        case MessageResponse.Abandoned:
                            await AbandonAsync(message).ConfigureAwait(false);
                            break;

                        default:
                            break;
                    }
                }
                catch (Exception ex) when (Logging.IsEnabled)
                {
                    Logging.Error(this, ex, nameof(OnModuleEventMessageReceivedAsync));
                    throw;
                }
            }
            finally
            {
                if (Logging.IsEnabled)
                    Logging.Exit(this, input, message, nameof(OnModuleEventMessageReceivedAsync));
            }
        }