FindHelper.cs

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Management.Automation;
using System.Net;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Azure;
using Microsoft.PowerShell.PSResourceGet.UtilClasses;
using NuGet.Protocol.Core.Types;
using NuGet.Versioning;

namespace Microsoft.PowerShell.PSResourceGet.Cmdlets
{
    /// <summary>
    /// Find helper class provides the core functionality for FindPSResource.
    /// </summary>
    internal class FindHelper
    {
        #region Members

        private CancellationToken _cancellationToken;
        private readonly PSCmdlet _cmdletPassedIn;
        private HashSet<string> _pkgsLeftToFind;
        private List<string> _tagsLeftToFind;
        private ResourceType _type;
        private string _version;
        private VersionRange _versionRange;
        private NuGetVersion _nugetVersion;
        private VersionType _versionType;
        private bool _prerelease = false;
        private string[] _tag;
        private bool _includeDependencies = false;
        private bool _repositoryNameContainsWildcard = true;
        private NetworkCredential _networkCredential;

        // Gets intantiated each time a cmdlet is run.
        // If running 'Install-PSResource Az, TestModule, NewTestModule', it will contain one parent and its dependencies.
        private ConcurrentDictionary<string, List<string>> _packagesFound;

        // Creates a new instance of depPkgsFound each time FindDependencyPackages() is called.
        // This will eventually return the PSResourceInfo object to the main cmdlet class.
        private ConcurrentDictionary<string, PSResourceInfo> depPkgsFound;
        
        // Contains the latest found version of a particular package.
        private ConcurrentDictionary<string, PSResourceInfo> _knownLatestPkgVersion;

        ConcurrentDictionary<string, Task<FindResults>> _cachedNetworkCalls;

        #endregion

        #region Constructor

        private FindHelper() { }

        public FindHelper(CancellationToken cancellationToken, PSCmdlet cmdletPassedIn, NetworkCredential networkCredential)
        {
            _cancellationToken = cancellationToken;
            _cmdletPassedIn = cmdletPassedIn;
            _networkCredential = networkCredential;
            _packagesFound = new ConcurrentDictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
            _knownLatestPkgVersion = new ConcurrentDictionary<string, PSResourceInfo>(StringComparer.OrdinalIgnoreCase);
            _type = ResourceType.None;
            _cachedNetworkCalls = new ConcurrentDictionary<string, Task<FindResults>>();
        }

        #endregion

        #region Public Methods

        public IEnumerable<PSResourceInfo> FindByResourceName(
            string[] name,
            ResourceType type,
            VersionRange versionRange,
            NuGetVersion nugetVersion,
            VersionType versionType,
            string version,
            bool prerelease,
            string[] tag,
            string[] repository,
            bool includeDependencies,
            bool suppressErrors)
        {
            _type = type;
            _version = version;
            _prerelease = prerelease;
            _tag = tag ?? Utils.EmptyStrArray;
            _includeDependencies = includeDependencies;
            _versionRange = versionRange;
            _nugetVersion = nugetVersion;
            _versionType = versionType;

            _cmdletPassedIn.WriteDebug("In FindHelper::FindByResourceName()");
            _cmdletPassedIn.WriteDebug(string.Format("Parameters passed in >>> Name: '{0}'; ResourceType: '{1}'; VersionRange: '{2}'; NuGetVersion: '{3}'; VersionType: '{4}'; Version: '{5}'; Prerelease: '{6}'; " +
                "Tag: '{7}'; Repository: '{8}'; IncludeDependencies '{9}'",
                string.Join(",", name),
                type.ToString() ?? string.Empty,
                versionRange != null ? (versionRange.OriginalString != null ? versionRange.OriginalString : string.Empty) : string.Empty,
                nugetVersion != null ? nugetVersion.ToString() : string.Empty,
                versionType.ToString(),
                version != null ? version : String.Empty,
                prerelease.ToString(),
                tag != null ? string.Join(",", tag) : string.Empty,
                repository != null ? string.Join(",", repository) : string.Empty,
                includeDependencies.ToString()));

            if (name.Length == 0)
            {
                _cmdletPassedIn.WriteDebug("Names were not provided or could not be resolved");
                yield break;
            }

            _pkgsLeftToFind = new HashSet<string>(name, StringComparer.InvariantCultureIgnoreCase);
            HashSet<string> pkgsDiscovered = GetPackageNamesPopulated(_pkgsLeftToFind.ToArray());

            _tagsLeftToFind = tag == null ? new List<string>() : new List<string>(tag);

            if (repository != null)
            {
                // Write error and disregard repository entries containing wildcards.
                repository = Utils.ProcessNameWildcards(repository, removeWildcardEntries: false, out string[] errorMsgs, out _repositoryNameContainsWildcard);
                foreach (string error in errorMsgs)
                {
                    _cmdletPassedIn.WriteError(new ErrorRecord(
                        new PSInvalidOperationException(error),
                        "ErrorFilteringNamesForUnsupportedWildcards",
                        ErrorCategory.InvalidArgument,
                        this));
                }

                // If repository entries includes wildcards and non-wildcard names, write terminating error
                // Ex: -Repository *Gallery, localRepo
                bool containsWildcard = false;
                bool containsNonWildcard = false;
                foreach (string repoName in repository)
                {
                    if (repoName.Contains("*"))
                    {
                        containsWildcard = true;
                    }
                    else
                    {
                        containsNonWildcard = true;
                    }
                }

                if (containsNonWildcard && containsWildcard)
                {
                    _cmdletPassedIn.ThrowTerminatingError(new ErrorRecord(
                        new PSInvalidOperationException("Repository name with wildcard is not allowed when another repository without wildcard is specified."),
                        "RepositoryNamesWithWildcardsAndNonWildcardUnsupported",
                        ErrorCategory.InvalidArgument,
                        this));
                }
            }


            // At this point we can only have scenarios such as:
            // -Repository PSGallery
            // -Repository PSGallery, NuGetGallery -> search and write error for each
            // -Repository *Gallery -> write error if in none
            // No -Repository -> search all, write error if in none

            // Get repositories to search.
            List<PSRepositoryInfo> repositoriesToSearch;
            try
            {
                repositoriesToSearch = RepositorySettings.Read(repository, out string[] errorList);
                if (repositoriesToSearch != null && repositoriesToSearch.Count == 0)
                {
                    _cmdletPassedIn.ThrowTerminatingError(new ErrorRecord(
                        new PSArgumentException("Cannot resolve -Repository name. Run 'Get-PSResourceRepository' to view all registered repositories."),
                        "RepositoryNameIsNotResolved",
                        ErrorCategory.InvalidArgument,
                        this));
                }

                foreach (string error in errorList)
                {
                    _cmdletPassedIn.WriteError(new ErrorRecord(
                        new PSInvalidOperationException(error),
                        "ErrorRetrievingSpecifiedRepository",
                        ErrorCategory.InvalidOperation,
                        this));
                }
            }
            catch (Exception e)
            {
                _cmdletPassedIn.ThrowTerminatingError(new ErrorRecord(
                    new PSInvalidOperationException(e.Message),
                    "ErrorLoadingRepositoryStoreFile",
                    ErrorCategory.InvalidArgument,
                    this));

                yield break;
            }

            List<string> repositoryNamesToSearch = new List<string>();

            for (int i = 0; i < repositoriesToSearch.Count; i++)
            {
                PSRepositoryInfo currentRepository = repositoriesToSearch[i];

                bool isAllowed = GroupPolicyRepositoryEnforcement.IsRepositoryAllowed(currentRepository.Uri);

                if (!isAllowed)
                {
                    _cmdletPassedIn.WriteError(new ErrorRecord(
                        new PSInvalidOperationException($"Repository '{currentRepository.Name}' is not allowed by Group Policy."),
                        "RepositoryNotAllowedByGroupPolicy",
                        ErrorCategory.PermissionDenied,
                        this));

                    continue;
                }

                repositoryNamesToSearch.Add(currentRepository.Name);

                // Set network credentials via passed in credentials, AzArtifacts CredentialProvider, or SecretManagement.
                _networkCredential = currentRepository.SetNetworkCredentials(_networkCredential, _cmdletPassedIn);

                ServerApiCall currentServer = ServerFactory.GetServer(currentRepository, _cmdletPassedIn, _networkCredential);
                if (currentServer == null)
                {
                    // this indicates that PSRepositoryInfo.APIVersion = PSRepositoryInfo.APIVersion.unknown
                    _cmdletPassedIn.WriteError(new ErrorRecord(
                        new PSInvalidOperationException($"Repository '{currentRepository.Name}' is not a known repository type that is supported. Please file an issue for support at https://github.com/PowerShell/PSResourceGet/issues"),
                        "RepositoryApiVersionUnknown",
                        ErrorCategory.InvalidArgument,
                        this));

                    continue;
                }

                ResponseUtil currentResponseUtil = ResponseUtilFactory.GetResponseUtil(currentRepository);
                _cmdletPassedIn.WriteDebug($"Searching through repository '{currentRepository.Name}'");

                bool shouldReportErrorForEachRepo = !suppressErrors && !_repositoryNameContainsWildcard;
                foreach (PSResourceInfo currentPkg in SearchByNames(currentServer, currentResponseUtil, currentRepository, shouldReportErrorForEachRepo))
                {
                    if (currentPkg == null)
                    {
                        _cmdletPassedIn.WriteDebug("No packages returned from server");
                        continue;
                    }

                    string currentPkgName = currentPkg.Name;
                    _cmdletPassedIn.WriteDebug($"Package '{currentPkgName}' returned from server");
                    // Check if pkgsDiscovered dictionary contains this package name exactly, otherwise this may have been a package found for wildcard name input.
                    if (pkgsDiscovered.Contains(currentPkgName))
                    {
                        _cmdletPassedIn.WriteDebug($"Package '{currentPkgName}' was previously discovered and returned");
                        pkgsDiscovered.Remove(currentPkgName);
                    }

                    yield return currentPkg;
                }
            }

            if (!suppressErrors && _repositoryNameContainsWildcard)
            {
                // Scenarios: Find-PSResource -Name "pkg" -> write error only if pkg wasn't found in any registered repositories
                // Scenarios: Find-PSResource -Name "pkg" -Repository *Gallery -> write error if only if pkg wasn't found in any matching repositories.
                foreach (string pkgName in pkgsDiscovered)
                {
                    var msg = repository == null ? $"Package '{pkgName}' could not be found in any registered repositories." :
                        $"Package '{pkgName}' could not be found in registered repositories: '{string.Join(", ", repositoryNamesToSearch)}'.";

                    _cmdletPassedIn.WriteError(new ErrorRecord(
                        new ResourceNotFoundException(msg),
                        "PackageNotFound",
                        ErrorCategory.ObjectNotFound,
                        this));
                }
            }
        }

        public IEnumerable<PSCommandResourceInfo> FindByCommandOrDscResource(
            bool isSearchingForCommands,
            bool prerelease,
            string[] tag,
            string[] repository)
        {
            _prerelease = prerelease;
            _tag = tag;

            _cmdletPassedIn.WriteDebug("In FindHelper::FindByCommandOrDscResource()");
            _cmdletPassedIn.WriteDebug(string.Format("Parameters passed in >>> IsSearchingForCommands: '{0}'; Prerelease: '{1}'; Tag: '{2}'; Repository: '{3}'",
                isSearchingForCommands.ToString(),
                prerelease.ToString(),
                string.Join(",", tag),
                repository != null ? string.Join(",", repository) : string.Empty));

            if (_tag.Length == 0)
            {
                _cmdletPassedIn.WriteDebug("Tags were not provided or could not be resolved");
                yield break;
            }

            // Error out if repository array of names to be searched contains wildcards.
            if (repository != null)
            {
                repository = Utils.ProcessNameWildcards(repository, removeWildcardEntries: false, out string[] errorMsgs, out _repositoryNameContainsWildcard);

                if (string.Equals(repository[0], "*"))
                {
                    _cmdletPassedIn.ThrowTerminatingError(new ErrorRecord(
                        new PSArgumentException("-Repository parameter does not support entry '*' with -CommandName and -DSCResourceName parameters."),
                        "RepositoryDoesNotSupportWildcardEntryWithCmdOrDSCName",
                        ErrorCategory.InvalidArgument,
                        this));
                }

                foreach (string error in errorMsgs)
                {
                    _cmdletPassedIn.WriteError(new ErrorRecord(
                        new PSInvalidOperationException(error),
                        "ErrorFilteringNamesForUnsupportedWildcards",
                        ErrorCategory.InvalidArgument,
                        this));
                }

                // If repository entries includes wildcards and non-wildcard names, write terminating error
                // Ex: -Repository *Gallery, localRepo
                bool containsWildcard = false;
                bool containsNonWildcard = false;
                foreach (string repoName in repository)
                {
                    if (repoName.Contains("*"))
                    {
                        containsWildcard = true;
                    }
                    else
                    {
                        containsNonWildcard = true;
                    }
                }

                if (containsNonWildcard && containsWildcard)
                {
                    _cmdletPassedIn.ThrowTerminatingError(new ErrorRecord(
                        new PSInvalidOperationException("Repository name with wildcard is not allowed when another repository without wildcard is specified."),
                        "RepositoryNamesWithWildcardsAndNonWildcardUnsupported",
                        ErrorCategory.InvalidArgument,
                        this));
                }
            }

            // Get repositories to search.
            List<PSRepositoryInfo> repositoriesToSearch;
            try
            {
                repositoriesToSearch = RepositorySettings.Read(repository, out string[] errorList);
                if (repositoriesToSearch != null && repositoriesToSearch.Count == 0)
                {
                    _cmdletPassedIn.ThrowTerminatingError(new ErrorRecord(
                        new PSArgumentException("Cannot resolve -Repository name. Run 'Get-PSResourceRepository' to view all registered repositories."),
                        "RepositoryNameIsNotResolved",
                        ErrorCategory.InvalidArgument,
                        this));
                }

                foreach (string error in errorList)
                {
                    _cmdletPassedIn.WriteError(new ErrorRecord(
                        new PSInvalidOperationException(error),
                        "ErrorRetrievingSpecifiedRepository",
                        ErrorCategory.InvalidOperation,
                        this));
                }
            }
            catch (Exception e)
            {
                _cmdletPassedIn.ThrowTerminatingError(new ErrorRecord(
                    new PSInvalidOperationException(e.Message),
                    "ErrorLoadingRepositoryStoreFile",
                    ErrorCategory.InvalidArgument,
                    this));

                yield break;
            }

            List<string> repositoryNamesToSearch = new List<string>();
            // For tags that are representative of Commands or DSCResource names, all those tags must be present in the returned package.
            // The class inheriting from ServerApiCalls must ensure packages returned satisfied all Command/DSCResource tags.
            bool isCmdOrDSCTagFound = false;
            bool shouldReportErrorForEachRepo = !_repositoryNameContainsWildcard;
            for (int i = 0; i < repositoriesToSearch.Count; i++)
            {
                PSRepositoryInfo currentRepository = repositoriesToSearch[i];

                bool isAllowed = GroupPolicyRepositoryEnforcement.IsRepositoryAllowed(currentRepository.Uri);

                if (!isAllowed)
                {
                    _cmdletPassedIn.WriteError(new ErrorRecord(
                        new PSInvalidOperationException($"Repository '{currentRepository.Name}' is not allowed by Group Policy."),
                        "RepositoryNotAllowedByGroupPolicy",
                        ErrorCategory.PermissionDenied,
                        this));

                    continue;
                }

                repositoryNamesToSearch.Add(currentRepository.Name);

                // Set network credentials via passed in credentials, AzArtifacts CredentialProvider, or SecretManagement.
                _networkCredential = currentRepository.SetNetworkCredentials(_networkCredential, _cmdletPassedIn);

                ServerApiCall currentServer = ServerFactory.GetServer(currentRepository, _cmdletPassedIn, _networkCredential);
                if (currentServer == null)
                {
                    // this indicates that PSRepositoryInfo.APIVersion = PSRepositoryInfo.APIVersion.unknown
                    _cmdletPassedIn.WriteError(new ErrorRecord(
                        new PSInvalidOperationException($"Repository '{currentRepository.Name}' is not a known repository type that is supported. Please file an issue for support at https://github.com/PowerShell/PSResourceGet/issues"),
                        "RepositoryApiVersionUnknown",
                        ErrorCategory.InvalidArgument,
                        this));

                    continue;
                }

                ResponseUtil currentResponseUtil = ResponseUtilFactory.GetResponseUtil(currentRepository);

                _cmdletPassedIn.WriteDebug($"Searching in repository '{currentRepository.Name}' for tags: '{String.Join(",", _tag)}'");
                FindResults responses = currentServer.FindCommandOrDscResource(_tag, _prerelease, isSearchingForCommands, out ErrorRecord errRecord);
                if (errRecord != null)
                {
                    if (shouldReportErrorForEachRepo)
                    {
                        _cmdletPassedIn.WriteError(errRecord);
                    }
                    else
                    {
                        _cmdletPassedIn.WriteVerbose(errRecord.Exception.Message);
                    }

                    continue;
                }

                foreach (PSResourceResult currentResult in currentResponseUtil.ConvertToPSResourceResult(responses))
                {
                    if (currentResult.exception != null && !currentResult.exception.Message.Equals(string.Empty))
                    {
                        errRecord = new ErrorRecord(
                            new ResourceNotFoundException($"'{String.Join(", ", _tag)}' could not be found", currentResult.exception),
                            "FindCmdOrDscToPSResourceObjFailure",
                            ErrorCategory.NotSpecified,
                            this);

                        if (shouldReportErrorForEachRepo)
                        {
                            _cmdletPassedIn.WriteError(errRecord);
                        }
                        else
                        {
                            _cmdletPassedIn.WriteVerbose(errRecord.Exception.Message);
                        }

                        continue;
                    }

                    PSCommandResourceInfo currentCmdPkg = new PSCommandResourceInfo(_tag, currentResult.returnedObject);
                    isCmdOrDSCTagFound = true;
                    _cmdletPassedIn.WriteDebug($"Found Command or DSCResource with parent package '{currentCmdPkg.ParentResource.Name}'");

                    yield return currentCmdPkg;
                }
            }

            if (!isCmdOrDSCTagFound && !shouldReportErrorForEachRepo)
            {
                string parameterName = isSearchingForCommands ? "CommandName" : "DSCResourceName";
                var msg = repository == null ? $"Package with {parameterName} '{String.Join(", ", _tag)}' could not be found in any registered repositories." :
                    $"Package with {parameterName} '{String.Join(", ", _tag)}' could not be found in registered repositories: '{string.Join(", ", repositoryNamesToSearch)}'.";

                _cmdletPassedIn.WriteError(new ErrorRecord(
                    new ResourceNotFoundException(msg),
                    "PackageWithCmdOrDscNotFound",
                    ErrorCategory.ObjectNotFound,
                    this));
            }
        }

        public IEnumerable<PSResourceInfo> FindByTag(
            ResourceType type,
            bool prerelease,
            string[] tag,
            string[] repository)
        {
            _type = type;
            _prerelease = prerelease;
            _tag = tag;

            _cmdletPassedIn.WriteDebug("In FindHelper::FindByTag()");
            _cmdletPassedIn.WriteDebug(string.Format("Parameters passed in >>> ResourceType: '{0}'; Prerelease: '{1}'; Tag: '{2}'; Repository: '{3}'",
                type.ToString() ?? string.Empty,
                prerelease.ToString(),
                string.Join(",", tag),
                repository != null ? string.Join(",", repository) : string.Empty));

            if (_tag.Length == 0)
            {
                _cmdletPassedIn.WriteDebug("Tags were not provided or could not be resolved");
                yield break;
            }

            if (repository != null)
            {
                repository = Utils.ProcessNameWildcards(repository, removeWildcardEntries: false, out string[] errorMsgs, out _repositoryNameContainsWildcard);

                if (string.Equals(repository[0], "*"))
                {
                    _cmdletPassedIn.ThrowTerminatingError(new ErrorRecord(
                        new PSArgumentException("-Repository parameter does not support entry '*' with -Tag parameter."),
                        "RepositoryDoesNotSupportWildcardEntryWithTag",
                        ErrorCategory.InvalidArgument,
                        this));
                }

                foreach (string error in errorMsgs)
                {
                    _cmdletPassedIn.WriteError(new ErrorRecord(
                        new PSInvalidOperationException(error),
                        "ErrorFilteringNamesForUnsupportedWildcards",
                        ErrorCategory.InvalidArgument,
                        this));
                }

                // If repository entries includes wildcards and non-wildcard names, write terminating error
                // Ex: -Repository *Gallery, localRepo
                bool containsWildcard = false;
                bool containsNonWildcard = false;
                foreach (string repoName in repository)
                {
                    if (repoName.Contains("*"))
                    {
                        containsWildcard = true;
                    }
                    else
                    {
                        containsNonWildcard = true;
                    }
                }

                if (containsNonWildcard && containsWildcard)
                {
                    _cmdletPassedIn.ThrowTerminatingError(new ErrorRecord(
                        new PSInvalidOperationException("Repository name with wildcard is not allowed when another repository without wildcard is specified."),
                        "RepositoryNamesWithWildcardsAndNonWildcardUnsupported",
                        ErrorCategory.InvalidArgument,
                        this));
                }
            }

            // Get repositories to search.
            List<PSRepositoryInfo> repositoriesToSearch;
            try
            {
                repositoriesToSearch = RepositorySettings.Read(repository, out string[] errorList);
                if (repositoriesToSearch != null && repositoriesToSearch.Count == 0)
                {
                    _cmdletPassedIn.ThrowTerminatingError(new ErrorRecord(
                        new PSArgumentException("Cannot resolve -Repository name. Run 'Get-PSResourceRepository' to view all registered repositories."),
                        "RepositoryNameIsNotResolved",
                        ErrorCategory.InvalidArgument,
                        this));
                }

                foreach (string error in errorList)
                {
                    _cmdletPassedIn.WriteError(new ErrorRecord(
                        new PSInvalidOperationException(error),
                        "ErrorRetrievingSpecifiedRepository",
                        ErrorCategory.InvalidOperation,
                        this));
                }
            }
            catch (Exception e)
            {
                _cmdletPassedIn.ThrowTerminatingError(new ErrorRecord(
                    new PSInvalidOperationException(e.Message),
                    "ErrorLoadingRepositoryStoreFile",
                    ErrorCategory.InvalidArgument,
                    this));

                yield break;
            }

            // For Find-PSResource with -Tags, only packages that have *all* required tags are returned.
            // The class inheriting from ServerA1piCalls must ensure packages returned satisfied all tags.
            bool isTagFound = false;
            bool shouldReportErrorForEachRepo = !_repositoryNameContainsWildcard;
            List<string> repositoryNamesToSearch = new List<string>();
            for (int i = 0; i < repositoriesToSearch.Count; i++)
            {
                PSRepositoryInfo currentRepository = repositoriesToSearch[i];

                bool isAllowed = GroupPolicyRepositoryEnforcement.IsRepositoryAllowed(currentRepository.Uri);

                if (!isAllowed)
                {
                    _cmdletPassedIn.WriteError(new ErrorRecord(
                        new PSInvalidOperationException($"Repository '{currentRepository.Name}' is not allowed by Group Policy."),
                        "RepositoryNotAllowedByGroupPolicy",
                        ErrorCategory.PermissionDenied,
                        this));

                    continue;
                }

                repositoryNamesToSearch.Add(currentRepository.Name);

                // Set network credentials via passed in credentials, AzArtifacts CredentialProvider, or SecretManagement.
                _networkCredential = currentRepository.SetNetworkCredentials(_networkCredential, _cmdletPassedIn);

                ServerApiCall currentServer = ServerFactory.GetServer(currentRepository, _cmdletPassedIn, _networkCredential);
                if (currentServer == null)
                {
                    // this indicates that PSRepositoryInfo.APIVersion = PSRepositoryInfo.APIVersion.unknown
                    _cmdletPassedIn.WriteError(new ErrorRecord(
                        new PSInvalidOperationException($"Repository '{currentRepository.Name}' is not a known repository type that is supported. Please file an issue for support at https://github.com/PowerShell/PSResourceGet/issues"),
                        "RepositoryApiVersionUnknown",
                        ErrorCategory.InvalidArgument,
                        this));

                    continue;
                }

                ResponseUtil currentResponseUtil = ResponseUtilFactory.GetResponseUtil(currentRepository);
                _cmdletPassedIn.WriteDebug($"Searching through repository '{currentRepository.Name}'");
                if (_type != ResourceType.None && repositoriesToSearch[i].Name != "PSGallery")
                {
                    _cmdletPassedIn.ThrowTerminatingError(new ErrorRecord(
                        new PSInvalidOperationException("-Type parameter is only supported with the PowerShellGallery."),
                        "ErrorUsingTypeParameter",
                        ErrorCategory.InvalidOperation,
                        this));
                }

                FindResults responses = currentServer.FindTags(_tag, _prerelease, type, out ErrorRecord errRecord);
                if (errRecord != null)
                {
                    if (shouldReportErrorForEachRepo)
                    {
                        _cmdletPassedIn.WriteError(errRecord);
                    }
                    else
                    {
                        _cmdletPassedIn.WriteVerbose(errRecord.Exception.Message);
                    }

                    continue;
                }

                foreach (PSResourceResult currentResult in currentResponseUtil.ConvertToPSResourceResult(responses))
                {
                    if (currentResult.exception != null && !currentResult.exception.Message.Equals(string.Empty))
                    {
                        errRecord = new ErrorRecord(
                            new ResourceNotFoundException($"Tags '{String.Join(", ", _tag)}' could not be found", currentResult.exception),
                            "FindTagConvertToPSResourceFailure",
                            ErrorCategory.InvalidResult,
                            this);

                        if (shouldReportErrorForEachRepo)
                        {
                            _cmdletPassedIn.WriteError(errRecord);
                        }
                        else
                        {
                            _cmdletPassedIn.WriteVerbose(errRecord.Exception.Message);
                        }

                        continue;
                    }

                    isTagFound = true;
                    yield return currentResult.returnedObject;
                }
            }

            if (!isTagFound && !shouldReportErrorForEachRepo)
            {
                var msg = repository == null ? $"Package with Tags '{String.Join(", ", _tag)}' could not be found in any registered repositories." :
                    $"Package with Tags '{String.Join(", ", _tag)}' could not be found in registered repositories: '{string.Join(", ", repositoryNamesToSearch)}'.";

                _cmdletPassedIn.WriteError(new ErrorRecord(
                    new ResourceNotFoundException(msg),
                    "PackageWithTagsNotFound",
                    ErrorCategory.ObjectNotFound,
                    this));
            }
        }

        #endregion

        #region Private Client Search Methods

        private IEnumerable<PSResourceInfo> SearchByNames(ServerApiCall currentServer, ResponseUtil currentResponseUtil, PSRepositoryInfo repository, bool shouldReportErrorForEachRepo)
        {
            ErrorRecord errRecord = null;
            ConcurrentQueue<ErrorRecord> errorMsgs = new ConcurrentQueue<ErrorRecord>();
            ConcurrentQueue<string> warningMsgs = new ConcurrentQueue<string>();
            ConcurrentQueue<string> debugMsgs = new ConcurrentQueue<string>();
            ConcurrentQueue<string> verboseMsgs = new ConcurrentQueue<string>();
            List<PSResourceInfo> parentPkgs = new List<PSResourceInfo>();
            string tagsAsString = String.Empty;
            bool isV2Resource = currentResponseUtil is V2ResponseUtil;

            _cmdletPassedIn.WriteDebug("In FindHelper::SearchByNames()");
            foreach (string pkgName in _pkgsLeftToFind.ToArray())
            {
                if (_versionType == VersionType.NoVersion)
                {
                    if (pkgName.Trim().Equals("*"))
                    {
                        _cmdletPassedIn.WriteDebug("No version specified, package name is '*'");
                        // Example: Find-PSResource -Name "*"

                        // Note: Just for resources from V2 servers, specifically PSGallery, if the resource is unlisted and was requested non-explicitly 
                        // (i.e requested name has wildcard) the resource should not be returned and ResponseUtil.ConvertToPSResourceResult() call needs to be informed of this.
                        // In all other cases, return the resource regardless of whether it was requested explicitly or not.
                        bool isResourceRequestedWithWildcard = isV2Resource;

                        FindResults responses = currentServer.FindAll(_prerelease, _type, out errRecord);
                        if (errRecord != null)
                        {
                            if (shouldReportErrorForEachRepo)
                            {
                                _cmdletPassedIn.WriteError(errRecord);
                            }
                            else
                            {
                                _cmdletPassedIn.WriteVerbose(errRecord.Exception.Message);
                            }

                            continue;
                        }

                        foreach (PSResourceResult currentResult in currentResponseUtil.ConvertToPSResourceResult(responseResults: responses, isResourceRequestedWithWildcard))
                        {
                            if (currentResult.exception != null && !currentResult.exception.Message.Equals(string.Empty))
                            {
                                _cmdletPassedIn.WriteError(new ErrorRecord(
                                    currentResult.exception,
                                    "FindAllConvertToPSResourceFailure",
                                    ErrorCategory.InvalidResult,
                                    this));

                                continue;
                            }

                            PSResourceInfo foundPkg = currentResult.returnedObject;

                            if (foundPkg.Type == _type || _type == ResourceType.None)
                            {
                                parentPkgs.Add(foundPkg);
                                TryAddToPackagesFound(foundPkg);

                                yield return foundPkg;
                            }
                        }
                    }
                    else if (pkgName.Contains("*"))
                    {
                        // Example: Find-PSResource -Name "Az*"
                        // Example: Find-PSResource -Name "Az*" -Tag "Storage"
                        _cmdletPassedIn.WriteDebug("No version specified, package name contains a wildcard.");

                        // Note: Just for resources from V2 servers, specifically PSGallery, if the resource is unlisted and was requested non-explicitly 
                        // (i.e requested name has wildcard) the resource should not be returned and ResponseUtil.ConvertToPSResourceResult() call needs to be informed of this.
                        // In all other cases, return the resource regardless of whether it was requested explicitly or not.
                        bool isResourceRequestedWithWildcard = isV2Resource;
                        FindResults responses = null;
                        if (_tag.Length == 0)
                        {
                            responses = currentServer.FindNameGlobbing(pkgName, _prerelease, _type, out errRecord);
                        }
                        else
                        {
                            responses = currentServer.FindNameGlobbingWithTag(pkgName, _tag, _prerelease, _type, out errRecord);
                            tagsAsString = $" and tags '{String.Join(", ", _tag)}'";
                        }

                        if (errRecord != null)
                        {
                            if (shouldReportErrorForEachRepo)
                            {
                                _cmdletPassedIn.WriteError(errRecord);
                            }
                            else
                            {
                                _cmdletPassedIn.WriteVerbose(errRecord.Exception.Message);
                            }

                            continue;
                        }

                        foreach (PSResourceResult currentResult in currentResponseUtil.ConvertToPSResourceResult(responses, isResourceRequestedWithWildcard))
                        {
                            if (currentResult.exception != null && !currentResult.exception.Message.Equals(string.Empty))
                            {
                                _cmdletPassedIn.WriteError(new ErrorRecord(
                                    currentResult.exception,
                                    "FindNameGlobbingConvertToPSResourceFailure",
                                    ErrorCategory.InvalidResult,
                                    this));

                                continue;
                            }

                            PSResourceInfo foundPkg = currentResult.returnedObject;
                            parentPkgs.Add(foundPkg);
                            TryAddToPackagesFound(foundPkg);

                            yield return foundPkg;
                        }
                    }
                    else
                    {
                        // Example: Find-PSResource -Name "Az"
                        // Example: Find-PSResource -Name "Az" -Tag "Storage"
                        _cmdletPassedIn.WriteDebug("No version specified, package name is specified");

                        FindResults responses = null;
                        if (_tag.Length == 0)
                        {
                            responses = currentServer.FindName(pkgName, _prerelease, _type, out errRecord);
                        }
                        else
                        {
                            responses = currentServer.FindNameWithTag(pkgName, _tag, _prerelease, _type, out errRecord);
                            tagsAsString = $" and tags '{String.Join(", ", _tag)}'";
                        }

                        if (errRecord != null)
                        {
                            if (shouldReportErrorForEachRepo)
                            {
                                _cmdletPassedIn.WriteError(errRecord);
                            }
                            else
                            {
                                _cmdletPassedIn.WriteVerbose(errRecord.Exception.Message);
                            }

                            continue;
                        }

                        PSResourceResult currentResult = currentResponseUtil.ConvertToPSResourceResult(responses).FirstOrDefault();
                        if (currentResult == null)
                        {
                            // This scenario may occur when the package version requested is unlisted.
                            _cmdletPassedIn.WriteError(new ErrorRecord(
                                new ResourceNotFoundException($"Package with name '{pkgName}'{tagsAsString} could not be found in repository '{repository.Name}'"),
                                "PackageNotFound",
                                ErrorCategory.ObjectNotFound,
                                this));

                            continue;
                        }

                        if (currentResult.exception != null && !currentResult.exception.Message.Equals(string.Empty))
                        {
                            _cmdletPassedIn.WriteError(new ErrorRecord(
                                currentResult.exception,
                                "FindNameConvertToPSResourceFailure",
                                ErrorCategory.ObjectNotFound,
                                this));

                            continue;
                        }

                        PSResourceInfo foundPkg = currentResult.returnedObject;
                        parentPkgs.Add(foundPkg);
                        TryAddToPackagesFound(foundPkg);

                        yield return foundPkg;
                    }
                }
                else if (_versionType == VersionType.SpecificVersion)
                {
                    if (pkgName.Contains("*"))
                    {
                        _cmdletPassedIn.WriteError(new ErrorRecord(
                            new ArgumentException("Name cannot contain or equal wildcard when using specific version."),
                            "InvalidWildCardUsage",
                            ErrorCategory.InvalidOperation,
                            this));

                        continue;
                    }
                    else
                    {
                        // Example: Find-PSResource -Name "Az" -Version "3.0.0.0"
                        // Example: Find-PSResource -Name "Az" -Version "3.0.0.0" -Tag "Windows"
                        _cmdletPassedIn.WriteDebug("Exact version and package name are specified");

                        FindResults responses = null;
                        if (_tag.Length == 0)
                        {

                        
                            ConcurrentDictionary<string, Task<FindResults>> cachedNetworkCalls = new ConcurrentDictionary<string, Task<FindResults>>();
                            Task<FindResults> response = null;
                            if (currentServer.Repository.ApiVersion == PSRepositoryInfo.APIVersion.V2) {       
                                string key = $"{pkgName}|{_nugetVersion.ToNormalizedString()}|{_type}";
                                response = cachedNetworkCalls.GetOrAdd(key, _ => currentServer.FindVersionAsync(pkgName, _nugetVersion.ToNormalizedString(), _type, errorMsgs, warningMsgs, debugMsgs, verboseMsgs));
                    
                                responses = response.GetAwaiter().GetResult();

                                Utils.WriteOutConcurrentQueue(_cmdletPassedIn, errorMsgs, warningMsgs, debugMsgs, verboseMsgs);
                            }
                            else {         
                                responses = currentServer.FindVersion(pkgName, _nugetVersion.ToNormalizedString(), _type, out errRecord);
                            }
                        }
                        else
                        {
                            responses = currentServer.FindVersionWithTag(pkgName, _nugetVersion.ToNormalizedString(), _tag, _type, out errRecord);
                            tagsAsString = $" and tags '{String.Join(", ", _tag)}'";
                        }

                        if (errRecord != null)
                        {
                            if (shouldReportErrorForEachRepo)
                            {
                                _cmdletPassedIn.WriteError(errRecord);
                            }
                            else
                            {
                                _cmdletPassedIn.WriteVerbose(errRecord.Exception.Message);
                            }

                            continue;
                        }

                        PSResourceResult currentResult = currentResponseUtil.ConvertToPSResourceResult(responses).FirstOrDefault();
                        if (currentResult == null)
                        {
                            // This scenario may occur when the package version requested is unlisted.
                            _cmdletPassedIn.WriteError(new ErrorRecord(
                                new ResourceNotFoundException($"Package with name '{pkgName}', version '{_nugetVersion.ToNormalizedString()}'{tagsAsString} could not be found in repository '{repository.Name}'"),
                                "PackageNotFound",
                                ErrorCategory.ObjectNotFound,
                                this));

                            continue;
                        }

                        if (currentResult.exception != null && !currentResult.exception.Message.Equals(string.Empty))
                        {
                            _cmdletPassedIn.WriteError(new ErrorRecord(
                                currentResult.exception,
                                "FindVersionConvertToPSResourceFailure",
                                ErrorCategory.ObjectNotFound,
                                this));

                            continue;
                        }

                        PSResourceInfo foundPkg = currentResult.returnedObject;
                        parentPkgs.Add(foundPkg);
                        TryAddToPackagesFound(foundPkg);

                        yield return foundPkg;
                    }
                }
                else
                {
                    // version type is Version Range
                    if (pkgName.Contains("*"))
                    {
                        _cmdletPassedIn.WriteError(new ErrorRecord(
                            new ArgumentException("Name cannot contain or equal wildcard when using version range"),
                            "InvalidWildCardUsage",
                            ErrorCategory.InvalidOperation,
                            this));
                    }
                    else
                    {
                        // Example: Find-PSResource -Name "Az" -Version "[1.0.0.0, 3.0.0.0]"
                        _cmdletPassedIn.WriteDebug("Version range and package name are specified");

                        FindResults responses = null;
                        if (_tag.Length == 0)
                        {
                            ConcurrentDictionary<string, Task<FindResults>> cachedNetworkCalls = new ConcurrentDictionary<string, Task<FindResults>>();
                            Task<FindResults> response = null;
                            if (currentServer.Repository.ApiVersion == PSRepositoryInfo.APIVersion.V2) {       
                                string key = $"{pkgName}|{_versionRange.ToString()}|{_type}";
                                response = cachedNetworkCalls.GetOrAdd(key, _ => currentServer.FindVersionGlobbingAsync(pkgName, _versionRange, _prerelease, _type, getOnlyLatest: false, errorMsgs, warningMsgs, debugMsgs, verboseMsgs));
                                
                                responses = response.GetAwaiter().GetResult();
                            }
                            else {         
                               responses = currentServer.FindVersionGlobbing(pkgName, _versionRange, _prerelease, _type, getOnlyLatest: false, out errRecord);    
                            }
                        }
                        else
                        {
                            _cmdletPassedIn.WriteError(new ErrorRecord(
                                new ArgumentException("-Tag parameter cannot be specified when using version range."),
                                "InvalidWildCardUsage",
                                ErrorCategory.InvalidOperation,
                                this));

                            continue;
                        }

                        if (errRecord != null)
                        {
                            if (shouldReportErrorForEachRepo)
                            {
                                _cmdletPassedIn.WriteError(errRecord);
                            }
                            else
                            {
                                _cmdletPassedIn.WriteVerbose(errRecord.Exception.Message);
                            }

                            continue;
                        }

                        foreach (PSResourceResult currentResult in currentResponseUtil.ConvertToPSResourceResult(responses))
                        {
                            // This currently catches for V2ServerApiCalls where the package was not found
                            if (currentResult.exception != null && !currentResult.exception.Message.Equals(string.Empty))
                            {
                                _cmdletPassedIn.WriteError(new ErrorRecord(
                                    currentResult.exception,
                                    "FindVersionGlobbingConvertToPSResourceFailure",
                                    ErrorCategory.ObjectNotFound,
                                    this));

                                continue;
                            }

                            // Check to see if version falls within version range
                            PSResourceInfo foundPkg = currentResult.returnedObject;
                            string versionStr = $"{foundPkg.Version}";
                            if (foundPkg.IsPrerelease)
                            {
                                versionStr += $"-{foundPkg.Prerelease}";
                            }

                            if (NuGetVersion.TryParse(versionStr, out NuGetVersion version)
                                   && _versionRange.Satisfies(version))
                            {
                                parentPkgs.Add(foundPkg);
                                TryAddToPackagesFound(foundPkg);

                                yield return foundPkg;
                            }
                        }
                    }
                }
            }

            // After retrieving all packages find their dependencies
            if (_includeDependencies)
            {
                foreach (PSResourceInfo currentPkg in parentPkgs)
                {
                    foreach (PSResourceInfo pkgDep in FindDependencyPackages(currentServer, currentResponseUtil, currentPkg, repository))
                    {
                        yield return pkgDep;
                    }
                }
            }
        }

        /// <summary>
        /// Iterates over package names passed in by user, and populates non-wildcard names into a HashSet.
        /// Since we only write errors for non-wildcard names, this is used to track discovery and report errors.
        /// </summary>
        private HashSet<string> GetPackageNamesPopulated(string[] pkgNames)
        {
            HashSet<string> pkgsToDiscover = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            foreach (string name in pkgNames)
            {
                if (!name.Contains("*"))
                {
                    pkgsToDiscover.Add(name);
                }
            }

            return pkgsToDiscover;
        }

        private bool TryAddToPackagesFound(PSResourceInfo foundPkg)
        {            
            // This handles prerelease versions as well.
            bool addedToHash = false;
            string foundPkgName = foundPkg.Name;
            string foundPkgVersion = FormatPkgVersionString(foundPkg); 

            if (_packagesFound.ContainsKey(foundPkgName))
            {
                _packagesFound.TryGetValue(foundPkgName, out List<string> pkgVersions);

                if (!pkgVersions.Contains(foundPkgVersion))
                {
                    List<string> newPkgVersions = new List<string>(pkgVersions)
                    {
                        foundPkgVersion
                    };
                    _packagesFound.TryUpdate(foundPkgName, newPkgVersions, pkgVersions);
                    
                    addedToHash = true;
                }
            }
            else
            {
                _packagesFound.TryAdd(foundPkg.Name, new List<string> { foundPkgVersion });
                addedToHash = true;
            }

            return addedToHash;
        }

        private bool TryAddToKnownLatestPkgVersion(PSResourceInfo foundPkg)
        {
            // This handles prerelease versions as well.
            bool addedToHash = false;
            string foundPkgName = foundPkg.Name;
            string foundPkgVersion = FormatPkgVersionString(foundPkg);

            if (_knownLatestPkgVersion.ContainsKey(foundPkgName))
            {
                _knownLatestPkgVersion.TryGetValue(foundPkgName, out PSResourceInfo oldPkgVersion);
                _knownLatestPkgVersion.TryUpdate(foundPkgName, foundPkg, oldPkgVersion);
                addedToHash = true;
            }
            else
            {
                _knownLatestPkgVersion.TryAdd(foundPkg.Name, foundPkg);
                addedToHash = true;
            }

            return addedToHash;
        }

        private string FormatPkgVersionString(PSResourceInfo pkg)
        {
            string fullPkgVersion = pkg.Version.ToString();
            if (!string.IsNullOrWhiteSpace(pkg.Prerelease))
            {
                fullPkgVersion += $"-{pkg.Prerelease}";
            }

            return fullPkgVersion;
        }

        #endregion

        #region Internal Client Search Methods

        internal IEnumerable<PSResourceInfo> FindDependencyPackages(ServerApiCall currentServer, ResponseUtil currentResponseUtil, PSResourceInfo currentPkg, PSRepositoryInfo repository)
        {
            depPkgsFound = new ConcurrentDictionary<string, PSResourceInfo>();
            _cmdletPassedIn.WriteDebug($"In FindHelper::FindDependencyPackages() - {currentPkg.Name}");            
            FindDependencyPackagesHelper(currentServer, currentResponseUtil, currentPkg, repository); 

            return depPkgsFound.Values.ToList();
        }

        // Method 2 
        internal void FindDependencyPackagesHelper(ServerApiCall currentServer, ResponseUtil currentResponseUtil, PSResourceInfo currentPkg, PSRepositoryInfo repository)
        {
            ConcurrentQueue<ErrorRecord> errorMsgs = new ConcurrentQueue<ErrorRecord>();
            ConcurrentQueue<string> verboseMsgs = new ConcurrentQueue<string>();
            ConcurrentQueue<string> debugMsgs = new ConcurrentQueue<string>();
            ConcurrentQueue<string> warningMsgs = new ConcurrentQueue<string>();
            debugMsgs.Enqueue("In FindHelper::FindDependencyPackagesHelper()");

            if (currentPkg.Dependencies.Length > 0)
            {
                // If finding more than 5 packages, do so concurrently
                //const int PARALLEL_THRESHOLD = 5; // TODO: Trottle limit from user, defaults to 5; 
                int processorCount = Environment.ProcessorCount;
                int maxDegreeOfParallelism = processorCount * 4;
                if (currentServer.Repository.ApiVersion == PSRepositoryInfo.APIVersion.V2 && currentPkg.Dependencies.Length > processorCount)
                {
                    Parallel.ForEach(currentPkg.Dependencies, new ParallelOptions { MaxDegreeOfParallelism = maxDegreeOfParallelism }, dep =>
                    {
                        debugMsgs.Enqueue($"Finding dependency '{dep.Name}' version range '{dep.VersionRange}'");
                        FindDependencyPackageVersion(dep, currentServer, currentResponseUtil, currentPkg, repository, errorMsgs, warningMsgs, debugMsgs, verboseMsgs);
                    });
                }
                else
                {
                    foreach (var dep in currentPkg.Dependencies)
                    {
                        debugMsgs.Enqueue($"Finding dependency '{dep.Name}' version range '{dep.VersionRange}'");
                        FindDependencyPackageVersion(dep, currentServer, currentResponseUtil, currentPkg, repository, errorMsgs, warningMsgs, debugMsgs, verboseMsgs);
                    }
                }

                Utils.WriteOutConcurrentQueue(_cmdletPassedIn, errorMsgs, warningMsgs, debugMsgs, verboseMsgs);
            }
        }

        // Method 3
        private void FindDependencyPackageVersion(
            Dependency dep, 
            ServerApiCall currentServer, 
            ResponseUtil currentResponseUtil, 
            PSResourceInfo currentPkg, 
            PSRepositoryInfo repository, 
            ConcurrentQueue<ErrorRecord> errorMsgs, 
            ConcurrentQueue<string> warningMsgs,
            ConcurrentQueue<string> debugMsgs,
            ConcurrentQueue<string> verboseMsgs)
        {
            PSResourceInfo depPkg = null;
            debugMsgs.Enqueue("In FindHelper::FindDependencyPackageVersion()");

            if (dep.VersionRange.Equals(VersionRange.All) || !dep.VersionRange.HasUpperBound)
            {
                    // Case 1: No upper bound, eg: "*" or "(1.0.0, )"
                    // Check if the latest version is cached
                    if (_knownLatestPkgVersion.TryGetValue(dep.Name, out PSResourceInfo cachedDepPkg))
                    {
                        verboseMsgs.Enqueue($"Dependency '{dep.Name}', with no upper bound version, was found in cache");
                        depPkg = cachedDepPkg;
                    }
                    else
                    {
                        // Find this version from the server
                        depPkg = FindDependencyWithLowerBound(dep, currentServer, currentResponseUtil, currentPkg, repository, errorMsgs, warningMsgs, debugMsgs, verboseMsgs);
                    }
            }
            else if (dep.VersionRange.HasLowerBound && dep.VersionRange.MinVersion.Equals(dep.VersionRange.MaxVersion))
            {
                // Case 2: Exact package version, eg: "1.0.0" or "[1.0.0, 1.0.0]"
                // Note:  need to check if VersionRange has lower bound because if it does not, MinVersion will be null
                // Check if the latest version is cached, and if this latest version is the version we're looking for
                if (_knownLatestPkgVersion.TryGetValue(dep.Name, out PSResourceInfo cachedRangePkg) &&
                    NuGetVersion.TryParse(cachedRangePkg.Version?.ToString(), out NuGetVersion cachedPkgVersion) &&
                    dep.VersionRange.Satisfies(cachedPkgVersion))
                {
                    verboseMsgs.Enqueue($"Dependency '{dep.Name}', with exact version, was found in cache");
                    depPkg = cachedRangePkg;
                }
                else
                {
                    depPkg = FindDependencyWithSpecificVersion(dep, currentServer, currentResponseUtil, currentPkg, repository, errorMsgs, warningMsgs, debugMsgs, verboseMsgs);
                }
            }
            else
            {                
                // Case 3: Version range with an upper bound, eg: "(1.0.0, 3.0.0)"
                // Check if the latest version is cached, and if this latest version is the version we're looking for
                if (_knownLatestPkgVersion.TryGetValue(dep.Name, out PSResourceInfo cachedRangePkg) &&
                    NuGetVersion.TryParse(cachedRangePkg.Version?.ToString(), out NuGetVersion cachedPkgVersion) &&
                    dep.VersionRange.Satisfies(cachedPkgVersion))
                {
                    verboseMsgs.Enqueue($"Dependency '{dep.Name}', with upper bound version, was found in cache");
                    depPkg = cachedRangePkg;
                }
                else
                {
                    depPkg = FindDependencyWithUpperBound(dep, currentServer, currentResponseUtil, currentPkg, repository, errorMsgs, warningMsgs, debugMsgs, verboseMsgs);
                }
            }
        }

        // Method 4
        private PSResourceInfo FindDependencyWithSpecificVersion(
            Dependency dep, 
            ServerApiCall currentServer, 
            ResponseUtil currentResponseUtil, 
            PSResourceInfo currentPkg, 
            PSRepositoryInfo repository, 
            ConcurrentQueue<ErrorRecord> errorMsgs, 
            ConcurrentQueue<string> warningMsgs,
            ConcurrentQueue<string> debugMsgs,
            ConcurrentQueue<string> verboseMsgs)
        {
            PSResourceInfo depPkg = null;
            ErrorRecord errRecord = null;
            FindResults responses = null;
            Task<FindResults> response = null;
            debugMsgs.Enqueue("In FindHelper::FindDependencyWithSpecificVersion()");

            if (currentServer.Repository.ApiVersion == PSRepositoryInfo.APIVersion.V2)
            {
                // See if the network call we're making is already cached, if not, call FindNameAsync() and cache results
                string key = $"{dep.Name}|{dep.VersionRange.MaxVersion.ToString()}|{_type}";
                debugMsgs.Enqueue("Checking if network call is cached.");
                response = _cachedNetworkCalls.GetOrAdd(key, _ => currentServer.FindVersionAsync(dep.Name, dep.VersionRange.MaxVersion.ToString(), _type, errorMsgs, warningMsgs, debugMsgs, verboseMsgs));
                
                responses = response.GetAwaiter().GetResult();
            }
            else
            {
                responses = currentServer.FindVersion(dep.Name, dep.VersionRange.MaxVersion.ToString(), _type, out errRecord);
            }


            // Error handling and Convert to PSResource object
            if (errRecord != null)
            {
                errorMsgs.Enqueue(new ErrorRecord(
                    new ResourceNotFoundException($"Dependency package could not be found: '{errRecord.Exception.Message}'"),
                    "DependencyPackageNotFound",
                    ErrorCategory.ObjectNotFound,
                    this));
            }
            else
            {
                PSResourceResult currentResult = currentResponseUtil.ConvertToPSResourceResult(responses).FirstOrDefault();
                if (currentResult == null || currentResult.exception != null && !currentResult.exception.Message.Equals(string.Empty))
                {
                    errorMsgs.Enqueue(new ErrorRecord(
                        new ResourceNotFoundException($"Dependency package with name '{dep.Name}' and version range '{dep.VersionRange}' could not be found in repository '{repository.Name}'", currentResult?.exception ?? new ItemNotFoundException()),
                        "DependencyPackageNotFound",
                        ErrorCategory.ObjectNotFound,
                        this));
                }
                else
                {
                    depPkg = currentResult.returnedObject;
                    TryAddToKnownLatestPkgVersion(depPkg);

                    string pkgVersion = FormatPkgVersionString(depPkg);
                    debugMsgs.Enqueue($"Found dependency '{depPkg.Name}' version '{pkgVersion}'");
                    string key = $"{depPkg.Name}{pkgVersion}";
                    if (!depPkgsFound.ContainsKey(key))
                    {
                        // Add pkg to collection of packages found then find dependencies
                        // depPkgsFound creates a new instance of depPkgsFound each time FindDependencyPackages() is called.
                        // This will eventually return the PSResourceInfo object to the main cmdlet class.
                        debugMsgs.Enqueue($"Adding'{key}' to list of dependency packages found");
                        depPkgsFound.TryAdd(key, depPkg);
                        FindDependencyPackagesHelper(currentServer, currentResponseUtil, depPkg, repository);
                    }
                }
            }

            return depPkg;
        }

        // Method 5
        private PSResourceInfo FindDependencyWithLowerBound(
            Dependency dep, 
            ServerApiCall currentServer, 
            ResponseUtil currentResponseUtil, 
            PSResourceInfo currentPkg, 
            PSRepositoryInfo repository, 
            ConcurrentQueue<ErrorRecord> errorMsgs, 
            ConcurrentQueue<string> warningMsgs,
            ConcurrentQueue<string> debugMsgs,
            ConcurrentQueue<string> verboseMsgs) 
        {
            PSResourceInfo depPkg = null;
            FindResults responses = null;
            ErrorRecord errRecord = null;
            Task<FindResults> response = null;
            debugMsgs.Enqueue("In FindHelper::FindDependencyWithLowerBound()");

            if (currentServer.Repository.ApiVersion == PSRepositoryInfo.APIVersion.V2)
            {
                // See if the network call we're making is already cached, if not, call FindNameAsync() and cache results
                string key = $"{dep.Name}|*|{_type}";
                debugMsgs.Enqueue("Checking if network call is cached.");
                response = _cachedNetworkCalls.GetOrAdd(key, _ => currentServer.FindNameAsync(dep.Name, includePrerelease: true, _type, errorMsgs, warningMsgs, debugMsgs, verboseMsgs));
                
                responses = response.GetAwaiter().GetResult();
            }
            else
            {
                responses = currentServer.FindName(dep.Name, includePrerelease: true, _type, out errRecord);
            }

            // Error handling and Convert to PSResource object
            if (errRecord != null)
            {
                errorMsgs.Enqueue(new ErrorRecord(
                    new ResourceNotFoundException($"Dependency package could not be found: '{errRecord.Exception.Message}'"),
                    "DependencyPackageNotFound",
                    ErrorCategory.ObjectNotFound,
                    this));
            }
            else
            {
                PSResourceResult currentResult = currentResponseUtil.ConvertToPSResourceResult(responses).FirstOrDefault();
                if (currentResult == null || currentResult.exception != null && !currentResult.exception.Message.Equals(string.Empty))
                {
                    errorMsgs.Enqueue(new ErrorRecord(
                        new ResourceNotFoundException($"Dependency package with name '{dep.Name}' and version range '{dep.VersionRange}' could not be found in repository '{repository.Name}'", currentResult?.exception ?? new ItemNotFoundException()),
                        "DependencyPackageNotFound",
                        ErrorCategory.ObjectNotFound,
                        this));
                }
                else
                {
                    depPkg = currentResult.returnedObject;
                    TryAddToKnownLatestPkgVersion(depPkg);

                    string pkgVersion = FormatPkgVersionString(depPkg);
                    debugMsgs.Enqueue($"Found dependency '{depPkg.Name}' version '{pkgVersion}'");
                    string key = $"{depPkg.Name}{pkgVersion}";
                    if (!depPkgsFound.ContainsKey(key))
                    {
                        // Add pkg to collection of packages found then find dependencies
                        // depPkgsFound creates a new instance of depPkgsFound each time FindDependencyPackages() is called.
                        // This will eventually return the PSResourceInfo object to the main cmdlet class.
                        debugMsgs.Enqueue($"Adding'{key}' to list of dependency packages found");
                        depPkgsFound.TryAdd(key, depPkg);
                        FindDependencyPackagesHelper(currentServer, currentResponseUtil, depPkg, repository);
                    }
                }
            }

            return depPkg;
        }

        // Method 6
        private PSResourceInfo FindDependencyWithUpperBound(
            Dependency dep, 
            ServerApiCall currentServer, 
            ResponseUtil currentResponseUtil, 
            PSResourceInfo currentPkg, 
            PSRepositoryInfo repository, 
            ConcurrentQueue<ErrorRecord> errorMsgs, 
            ConcurrentQueue<string> warningMsgs,
            ConcurrentQueue<string> debugMsgs,
            ConcurrentQueue<string> verboseMsgs)
        {
            PSResourceInfo depPkg = null;
            ErrorRecord errRecord = null;
            FindResults responses = null;
            Task<FindResults> response = null;

            ConcurrentDictionary<string, Task<FindResults>> cachedNetworkCalls = new ConcurrentDictionary<string, Task<FindResults>>();
            debugMsgs.Enqueue("In FindHelper::FindDependencyWithUpperBound()");

            if (currentServer.Repository.ApiVersion == PSRepositoryInfo.APIVersion.V2)
            {
                // See if the network call we're making is already caced, if not, call FindNameAsync() and cache results
                string key = $"{dep.Name}|{dep.VersionRange.MaxVersion.ToString()}|{_type}";
                debugMsgs.Enqueue("Checking if network call is cached.");
                response = cachedNetworkCalls.GetOrAdd(key, _ => currentServer.FindVersionGlobbingAsync(dep.Name, dep.VersionRange, includePrerelease: true, ResourceType.None, getOnlyLatest: true, errorMsgs, warningMsgs, debugMsgs, verboseMsgs));

                responses = response.GetAwaiter().GetResult();

            }
            else
            {
                responses = currentServer.FindVersionGlobbing(dep.Name, dep.VersionRange, includePrerelease: true, ResourceType.None, getOnlyLatest: true, out errRecord);
            }

            // Error handling and Convert to PSResource object
            if (errRecord != null)
            {
                errorMsgs.Enqueue(new ErrorRecord(
                    new ResourceNotFoundException($"Dependency package could not be found: '{errRecord.Exception.Message}'"),
                    "DependencyPackageNotFound",
                    ErrorCategory.ObjectNotFound,
                    this));
            }
            else
            {
                PSResourceResult currentResult = currentResponseUtil.ConvertToPSResourceResult(responses).FirstOrDefault();
                if (currentResult == null || currentResult.exception != null && !currentResult.exception.Message.Equals(string.Empty))
                {
                    errorMsgs.Enqueue(new ErrorRecord(
                        new ResourceNotFoundException($"Dependency package with name '{dep.Name}' and version range '{dep.VersionRange}' could not be found in repository '{repository.Name}'", currentResult?.exception ?? new ItemNotFoundException()),
                        "DependencyPackageNotFound",
                        ErrorCategory.ObjectNotFound,
                        this));
                }
                else
                {
                    depPkg = currentResult.returnedObject;

                    TryAddToKnownLatestPkgVersion(depPkg);

                    string pkgVersion = FormatPkgVersionString(depPkg);
                    debugMsgs.Enqueue($"Found dependency '{depPkg.Name}' version '{pkgVersion}'");
                    string key = $"{depPkg.Name}{pkgVersion}";
                    if (!depPkgsFound.ContainsKey(key))
                    {
                        // Add pkg to collection of packages found then find dependencies
                        // depPkgsFound creates a new instance of depPkgsFound each time FindDependencyPackages() is called.
                        // This will eventually return the PSResourceInfo object to the main cmdlet class.
                        debugMsgs.Enqueue($"Adding'{key}' to list of dependency packages found");
                        depPkgsFound.TryAdd(key, depPkg);
                        FindDependencyPackagesHelper(currentServer, currentResponseUtil, depPkg, repository);
                    }
                }
            }
            
            return depPkg;
        }

        #endregion
    }
}