public async Task ExecuteCommandAsync()

in src/NuGet.Core/NuGet.Commands/TrustedSignersCommand/TrustedSignersCommandRunner.cs [38:199]
125 lines of code
32 McCabe index (conditional complexity)

        public async Task<int> ExecuteCommandAsync(TrustedSignersArgs trustedSignersArgs)
        {
            var logger = trustedSignersArgs.Logger ?? NullLogger.Instance;
            var actionsProvider = new TrustedSignerActionsProvider(_trustedSignersProvider, logger);

            switch (trustedSignersArgs.Action)
            {
                case TrustedSignersAction.List:
                    ValidateListArguments(trustedSignersArgs);

                    await ListAllTrustedSignersAsync(logger);

                    break;

                case TrustedSignersAction.Add:
                    ValidateNameExists(trustedSignersArgs.Name);

                    var isPackagePathProvided = !string.IsNullOrEmpty(trustedSignersArgs.PackagePath);
                    var isServiceIndexProvided = !string.IsNullOrEmpty(trustedSignersArgs.ServiceIndex);
                    var isFingerprintProvided = !string.IsNullOrEmpty(trustedSignersArgs.CertificateFingerprint);
                    var isAlgorithmProvided = !string.IsNullOrEmpty(trustedSignersArgs.FingerprintAlgorithm);

                    if (isPackagePathProvided)
                    {
                        if (isServiceIndexProvided || isFingerprintProvided || isAlgorithmProvided)
                        {
                            throw new CommandLineArgumentCombinationException(string.Format(CultureInfo.CurrentCulture, Strings.Error_CouldNotAdd, Strings.Error_InvalidCombinationOfArguments));
                        }

                        if (!(trustedSignersArgs.Repository ^ trustedSignersArgs.Author))
                        {
                            throw new CommandLineArgumentCombinationException(string.Format(CultureInfo.CurrentCulture, Strings.Error_NoSignatureTrustedForPackage, trustedSignersArgs.PackagePath));
                        }

                        var trustTarget = VerificationTarget.None;
                        if (trustedSignersArgs.Author)
                        {
                            if (!trustedSignersArgs.Repository && trustedSignersArgs.Owners != null && trustedSignersArgs.Owners.Any())
                            {
                                throw new CommandLineArgumentCombinationException(Strings.Error_CannotTrustOwnersForAuthor);
                            }

                            trustTarget |= VerificationTarget.Author;
                        }

                        if (trustedSignersArgs.Repository)
                        {
                            trustTarget |= VerificationTarget.Repository;
                        }

                        if (trustTarget == VerificationTarget.None)
                        {
                            trustTarget = VerificationTarget.Unknown;
                        }

                        var packagesToTrust = LocalFolderUtility.ResolvePackageFromPath(trustedSignersArgs.PackagePath);
                        LocalFolderUtility.EnsurePackageFileExists(trustedSignersArgs.PackagePath, packagesToTrust);

                        if (packagesToTrust.Count() > 1)
                        {
                            throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
                                Strings.Multiple_Nupkgs_Detected,
                                trustedSignersArgs.PackagePath));
                        }

                        foreach (var package in packagesToTrust)
                        {
                            using (var packageReader = new PackageArchiveReader(package))
                            {
                                await actionsProvider.AddTrustedSignerAsync(
                                    trustedSignersArgs.Name,
                                    packageReader,
                                    trustTarget,
                                    trustedSignersArgs.AllowUntrustedRoot,
                                    trustedSignersArgs.Owners,
                                    CancellationToken.None);
                            }
                        }

                        break;
                    }

                    if (isServiceIndexProvided)
                    {
                        if (isFingerprintProvided || isAlgorithmProvided || trustedSignersArgs.Author || trustedSignersArgs.Repository)
                        {
                            throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.Error_CouldNotAdd, Strings.Error_InvalidCombinationOfArguments));
                        }

                        var serviceIndex = ValidateAndParseV3ServiceIndexUrl(trustedSignersArgs.ServiceIndex);

                        await actionsProvider.AddTrustedRepositoryAsync(
                            trustedSignersArgs.Name,
                            serviceIndex,
                            trustedSignersArgs.Owners,
                            CancellationToken.None);

                        break;
                    }

                    if (isFingerprintProvided)
                    {
                        if (trustedSignersArgs.Owners != null && trustedSignersArgs.Owners.Any())
                        {
                            throw new ArgumentException(Strings.Error_CannotTrustOwnersForAuthor);
                        }

                        var hashAlgorithm = ValidateAndParseFingerprintAlgorithm(trustedSignersArgs.FingerprintAlgorithm);

                        actionsProvider.AddOrUpdateTrustedSigner(
                            trustedSignersArgs.Name,
                            trustedSignersArgs.CertificateFingerprint,
                            hashAlgorithm,
                            trustedSignersArgs.AllowUntrustedRoot);

                        break;
                    }

                    if (isAlgorithmProvided || trustedSignersArgs.Author || trustedSignersArgs.Repository)
                    {
                        throw new CommandLineArgumentCombinationException(string.Format(CultureInfo.CurrentCulture, Strings.Error_CouldNotAdd, Strings.Error_InvalidCombinationOfArguments));
                    }

                    if (_packageSourceProvider == null)
                    {
                        throw new ArgumentException(Strings.Error_NoSourcesInformation);
                    }

                    var packageSource = _packageSourceProvider.GetPackageSourceByName(trustedSignersArgs.Name);
                    if (packageSource == null || string.IsNullOrEmpty(packageSource.Source))
                    {
                        throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.Error_UnavailableSource, trustedSignersArgs.Name));
                    }

                    var sourceServiceIndex = ValidateAndParseV3ServiceIndexUrl(packageSource.Source);

                    await actionsProvider.AddTrustedRepositoryAsync(
                        trustedSignersArgs.Name,
                        sourceServiceIndex,
                        trustedSignersArgs.Owners,
                        CancellationToken.None);


                    break;

                case TrustedSignersAction.Remove:
                    ValidateRemoveArguments(trustedSignersArgs);

                    await RemoveTrustedSignerAsync(trustedSignersArgs.Name, logger);

                    break;

                case TrustedSignersAction.Sync:
                    ValidateSyncArguments(trustedSignersArgs);

                    await actionsProvider.SyncTrustedRepositoryAsync(trustedSignersArgs.Name, CancellationToken.None);

                    break;
            }

            return SuccessCode;
        }