public async Task DeleteAsync()

in snipinsights/windows/SnipInsight/AppManager.cs [917:1080]
110 lines of code
22 McCabe index (conditional complexity)

        public async Task DeleteAsync(IEnumerable<SnipInsightLink> items, bool showConfirmation, bool raiseOutcomeTrigger)
        {
            ProgressControl progressMessage = null;

            // Filter out items that are already in the process of deleting!
            items = items.Where(i => i.DeletionPending == false).ToArray();

            int itemCount = items.Count();
            int failedCount = 0;

            if (itemCount == 0)
            {
                // There is nothing to do
                return;
            }

            try
            {
                // Mark all items as pending deletion
                foreach (var item in items)
                {
                    item.DeletionPending = true;
                }

                // Confirmation
                bool hasMixIds = items.Any(i => i.MixId != null);

                if (showConfirmation)
                {
                    bool deleteConfirmed = ShowDeleteConfirmation(itemCount, hasMixIds);

                    if (!deleteConfirmed) // No was clicked.
                    {
                        // Restore pending items
                        foreach (var item in items)
                        {
                            item.DeletionPending = false;
                        }

                        if (raiseOutcomeTrigger)
                        {
                            ViewModel.StateMachine.Fire(SnipInsightTrigger.DeletionCancelled);
                        }
                        return;
                    }
                }

                //
                // Do the actual delete
                //

                if (itemCount > 5 || hasMixIds)
                {
                    // Only bother with the Progress Bar if we think it might be slow...
                    // A large number or we need to call the server...

                    progressMessage = new ProgressControl();
                    progressMessage.ShowInMainWindow();
                }

                // If the Selected Package was deleted, we'll keep track of it's location
                int deletedSelectedPackageIndex = -1;

                int processedCount = 0;

                foreach (var item in items)
                {
                    var deletedIndex = GetCurrentContentIndexInLibrary(item);

                    var success = DeleteCore(item);

                    processedCount++;

                    if (progressMessage != null)
                    {
                        progressMessage.SetProgress(processedCount / itemCount);
                    }

                    if (success == true)
                    {
                        if (ViewModel.SelectedPackage != null && ViewModel.SelectedPackage.Url == item.Url)
                        {
                            // We just deleted the Selected Package! Remember this so we can choose a replacement
                            deletedSelectedPackageIndex = deletedIndex;
                            ViewModel.SelectedPackage = null;
                        }
                    }
                    else
                    {
                        failedCount++;

                        // Restore the item so the user can try again
                        item.DeletionPending = false;
                    }
                }

                if (progressMessage != null)
                {
                    progressMessage.Dismiss();
                    progressMessage = null;
                }

                //
                // Restore Selected Package
                //

                if (deletedSelectedPackageIndex != -1)
                {
                    // We deleted the SelectedPackage, so we need to restore it to something...
                    SelectPackageAfterDelete(deletedSelectedPackageIndex, raiseOutcomeTrigger);
                }
                else
                {
                    if (raiseOutcomeTrigger)
                    {
                        // We don't currently have a state for DeletionCompleted, but Cancelled should
                        // leave us in the same place
                        ViewModel.StateMachine.Fire(SnipInsightTrigger.DeletionCancelled);
                    }
                }

                //
                // Report any failures
                //

                if (failedCount > 0)
                {
                    Diagnostics.LogTrace(string.Format("Deletion failed for {0} item(s).", failedCount));
                    ToastControl toast = new ToastControl(string.Format(Resources.Delete_Failed_List, failedCount));
                    toast.ShowInMainWindow();
                    if (raiseOutcomeTrigger)
                    {
                        ViewModel.StateMachine.Fire(SnipInsightTrigger.DeletionFailed);
                    }

                }
            }
            catch (Exception ex)
            {
                if (progressMessage != null)
                {
                    progressMessage.Dismiss();
                    progressMessage = null;
                }

                Diagnostics.ReportException(ex);
                ToastControl toast = new ToastControl(Resources.Delete_Failed);
                toast.ShowInMainWindow();
                ViewModel.StateMachine.Fire(SnipInsightTrigger.DeletionFailed);
            }
            finally
            {
                //
                // Restore all items.
                // This is okay because those that were deleted should already be out of the list by now.
                //

                foreach (var item in items)
                {
                    item.DeletionPending = false;
                }

            }
        }