public async Task WaitForOrchestrationAsync()

in src/DurableTask.AzureStorage/AzureStorageOrchestrationService.cs [2015:2066]
43 lines of code
13 McCabe index (conditional complexity)

        public async Task<OrchestrationState?> WaitForOrchestrationAsync(
            string instanceId,
            string executionId,
            TimeSpan timeout,
            CancellationToken cancellationToken)
        {
            if (string.IsNullOrWhiteSpace(instanceId))
            {
                throw new ArgumentException(nameof(instanceId));
            }

            bool isInfiniteTimeSpan = timeout == Timeout.InfiniteTimeSpan;
            if (timeout < TimeSpan.Zero && !isInfiniteTimeSpan)
            {
                throw new ArgumentException($"The parameter {nameof(timeout)} cannot be negative." +
                    $" The value for {nameof(timeout)} was '{timeout}'." +
                    $" Please provide either a positive timeout value or Timeout.InfiniteTimeSpan.");
            }

            TimeSpan statusPollingInterval = TimeSpan.FromSeconds(2);
            while (!cancellationToken.IsCancellationRequested)
            {
                OrchestrationState? state = await this.GetOrchestrationStateAsync(instanceId, executionId);
                
                if (state != null &&
                    state.OrchestrationStatus != OrchestrationStatus.Running &&
                    state.OrchestrationStatus != OrchestrationStatus.Suspended &&
                    state.OrchestrationStatus != OrchestrationStatus.Pending &&
                    state.OrchestrationStatus != OrchestrationStatus.ContinuedAsNew)
                {
                    if (this.settings.FetchLargeMessageDataEnabled)
                    {
                        state.Input = await this.messageManager.FetchLargeMessageIfNecessary(state.Input);
                        state.Output = await this.messageManager.FetchLargeMessageIfNecessary(state.Output);
                    }
                    return state;
                }
                
                timeout -= statusPollingInterval;
                
                // For a user-provided timeout of `TimeSpan.Zero`,
                // we want to check the status of the orchestration once and then return.
                // Therefore, we check the timeout condition after the status check.
                if (!isInfiniteTimeSpan && (timeout <= TimeSpan.Zero))
                {
                    break;
                }
                await Task.Delay(statusPollingInterval, cancellationToken);
            }

            return null;
        }