// <auto-generated/>
 
#nullable enable annotations
#nullable disable warnings
 
// Suppress warnings about [Obsolete] member usage in generated code.
#pragma warning disable CS0612, CS0618
 
namespace System.Runtime.CompilerServices
{
    using System;
    using System.CodeDom.Compiler;
 
    [GeneratedCode("Microsoft.Extensions.Configuration.Binder.SourceGeneration", "8.0.10.31311")]
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
    file sealed class InterceptsLocationAttribute : Attribute
    {
        public InterceptsLocationAttribute(string filePath, int line, int column)
        {
        }
    }
}
 
namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration
{
    using Microsoft.Extensions.Configuration;
    using Microsoft.Extensions.DependencyInjection;
    using Microsoft.Extensions.Options;
    using System;
    using System.CodeDom.Compiler;
    using System.Collections.Generic;
    using System.Globalization;
    using System.Runtime.CompilerServices;
 
    [GeneratedCode("Microsoft.Extensions.Configuration.Binder.SourceGeneration", "8.0.10.31311")]
    file static class BindingExtensions
    {
        #region IConfiguration extensions.
        /// <summary>Attempts to bind the given object instance to configuration values by matching property names against configuration keys recursively.</summary>
        [InterceptsLocation(@"/_/src/Libraries/Microsoft.Extensions.Diagnostics.Probes/KubernetesProbesExtensions.cs", 36, 58)]
        public static void Bind_KubernetesProbesOptions(this IConfiguration configuration, object? instance)
        {
            if (configuration is null)
            {
                throw new ArgumentNullException(nameof(configuration));
            }
 
            if (instance is null)
            {
                return;
            }
 
            var typedObj = (global::Microsoft.Extensions.Diagnostics.Probes.KubernetesProbesOptions)instance;
            BindCore(configuration, ref typedObj, defaultValueIfNotFound: false, binderOptions: null);
        }
        #endregion IConfiguration extensions.
 
        #region IServiceCollection extensions.
        /// <summary>Registers a configuration instance which TOptions will bind against.</summary>
        [InterceptsLocation(@"/_/src/Libraries/Microsoft.Extensions.Diagnostics.Probes/TcpEndpointProbesExtensions.cs", 112, 22)]
        public static IServiceCollection Configure<TOptions>(this IServiceCollection services, IConfiguration config) where TOptions : class
        {
            return Configure<TOptions>(services, string.Empty, config, configureOptions: null);
        }
 
        /// <summary>Registers a configuration instance which TOptions will bind against.</summary>
        [InterceptsLocation(@"/_/src/Libraries/Microsoft.Extensions.Diagnostics.Probes/TcpEndpointProbesExtensions.cs", 133, 22)]
        public static IServiceCollection Configure<TOptions>(this IServiceCollection services, string? name, IConfiguration config) where TOptions : class
        {
            return Configure<TOptions>(services, name, config, configureOptions: null);
        }
 
        /// <summary>Registers a configuration instance which TOptions will bind against.</summary>
        public static IServiceCollection Configure<TOptions>(this IServiceCollection services, string? name, IConfiguration config, Action<BinderOptions>? configureOptions) where TOptions : class
        {
            if (services is null)
            {
                throw new ArgumentNullException(nameof(services));
            }
 
            if (config is null)
            {
                throw new ArgumentNullException(nameof(config));
            }
 
            OptionsServiceCollectionExtensions.AddOptions(services);
            services.AddSingleton<IOptionsChangeTokenSource<TOptions>>(new ConfigurationChangeTokenSource<TOptions>(name, config));
            return services.AddSingleton<IConfigureOptions<TOptions>>(new ConfigureNamedOptions<TOptions>(name, instance => BindCoreMain(config, instance, typeof(TOptions), configureOptions)));
        }
        #endregion IServiceCollection extensions.
 
        #region Core binding extensions.
        private readonly static Lazy<HashSet<string>> s_configKeys_TcpEndpointProbesOptions = new(() => new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "TcpPort", "MaxPendingConnections", "HealthAssessmentPeriod" });
        private readonly static Lazy<HashSet<string>> s_configKeys_KubernetesProbesOptions = new(() => new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "LivenessProbe", "StartupProbe", "ReadinessProbe" });
 
        public static void BindCoreMain(IConfiguration configuration, object instance, Type type, Action<BinderOptions>? configureOptions)
        {
            if (instance is null)
            {
                return;
            }
 
            if (!HasValueOrChildren(configuration))
            {
                return;
            }
 
            BinderOptions? binderOptions = GetBinderOptions(configureOptions);
 
            if (type == typeof(global::Microsoft.Extensions.Diagnostics.Probes.TcpEndpointProbesOptions))
            {
                var temp = (global::Microsoft.Extensions.Diagnostics.Probes.TcpEndpointProbesOptions)instance;
                BindCore(configuration, ref temp, defaultValueIfNotFound: false, binderOptions);
                return;
            }
 
            throw new NotSupportedException($"Unable to bind to type '{type}': generator did not detect the type as input.");
        }
 
        public static void BindCore(IConfiguration configuration, ref global::Microsoft.Extensions.Diagnostics.Probes.TcpEndpointProbesOptions instance, bool defaultValueIfNotFound, BinderOptions? binderOptions)
        {
            ValidateConfigurationKeys(typeof(global::Microsoft.Extensions.Diagnostics.Probes.TcpEndpointProbesOptions), s_configKeys_TcpEndpointProbesOptions, configuration, binderOptions);
 
            if (configuration["TcpPort"] is string value1)
            {
                instance.TcpPort = ParseInt(value1, () => configuration.GetSection("TcpPort").Path);
            }
            else if (defaultValueIfNotFound)
            {
                instance.TcpPort = default;
            }
 
            if (configuration["MaxPendingConnections"] is string value2)
            {
                instance.MaxPendingConnections = ParseInt(value2, () => configuration.GetSection("MaxPendingConnections").Path);
            }
            else if (defaultValueIfNotFound)
            {
                instance.MaxPendingConnections = default;
            }
 
            if (configuration["HealthAssessmentPeriod"] is string value3)
            {
                instance.HealthAssessmentPeriod = ParseSystemTimeSpan(value3, () => configuration.GetSection("HealthAssessmentPeriod").Path);
            }
            else if (defaultValueIfNotFound)
            {
                instance.HealthAssessmentPeriod = default;
            }
        }
 
        public static void BindCore(IConfiguration configuration, ref global::Microsoft.Extensions.Diagnostics.Probes.KubernetesProbesOptions instance, bool defaultValueIfNotFound, BinderOptions? binderOptions)
        {
            ValidateConfigurationKeys(typeof(global::Microsoft.Extensions.Diagnostics.Probes.KubernetesProbesOptions), s_configKeys_KubernetesProbesOptions, configuration, binderOptions);
 
            if (AsConfigWithChildren(configuration.GetSection("LivenessProbe")) is IConfigurationSection section4)
            {
                global::Microsoft.Extensions.Diagnostics.Probes.TcpEndpointProbesOptions? temp6 = instance.LivenessProbe;
                temp6 ??= new global::Microsoft.Extensions.Diagnostics.Probes.TcpEndpointProbesOptions();
                BindCore(section4, ref temp6, defaultValueIfNotFound: false, binderOptions);
                instance.LivenessProbe = temp6;
            }
 
            if (AsConfigWithChildren(configuration.GetSection("StartupProbe")) is IConfigurationSection section7)
            {
                global::Microsoft.Extensions.Diagnostics.Probes.TcpEndpointProbesOptions? temp9 = instance.StartupProbe;
                temp9 ??= new global::Microsoft.Extensions.Diagnostics.Probes.TcpEndpointProbesOptions();
                BindCore(section7, ref temp9, defaultValueIfNotFound: false, binderOptions);
                instance.StartupProbe = temp9;
            }
 
            if (AsConfigWithChildren(configuration.GetSection("ReadinessProbe")) is IConfigurationSection section10)
            {
                global::Microsoft.Extensions.Diagnostics.Probes.TcpEndpointProbesOptions? temp12 = instance.ReadinessProbe;
                temp12 ??= new global::Microsoft.Extensions.Diagnostics.Probes.TcpEndpointProbesOptions();
                BindCore(section10, ref temp12, defaultValueIfNotFound: false, binderOptions);
                instance.ReadinessProbe = temp12;
            }
        }
 
 
        /// <summary>If required by the binder options, validates that there are no unknown keys in the input configuration object.</summary>
        public static void ValidateConfigurationKeys(Type type, Lazy<HashSet<string>> keys, IConfiguration configuration, BinderOptions? binderOptions)
        {
            if (binderOptions?.ErrorOnUnknownConfiguration is true)
            {
                List<string>? temp = null;
        
                foreach (IConfigurationSection section in configuration.GetChildren())
                {
                    if (!keys.Value.Contains(section.Key))
                    {
                        (temp ??= new List<string>()).Add($"'{section.Key}'");
                    }
                }
        
                if (temp is not null)
                {
                    throw new InvalidOperationException($"'ErrorOnUnknownConfiguration' was set on the provided BinderOptions, but the following properties were not found on the instance of {type}: {string.Join(", ", temp)}");
                }
            }
        }
 
        public static bool HasValueOrChildren(IConfiguration configuration)
        {
            if ((configuration as IConfigurationSection)?.Value is not null)
            {
                return true;
            }
            return AsConfigWithChildren(configuration) is not null;
        }
 
        public static IConfiguration? AsConfigWithChildren(IConfiguration configuration)
        {
            foreach (IConfigurationSection _ in configuration.GetChildren())
            {
                return configuration;
            }
            return null;
        }
 
        public static BinderOptions? GetBinderOptions(Action<BinderOptions>? configureOptions)
        {
            if (configureOptions is null)
            {
                return null;
            }
        
            BinderOptions binderOptions = new();
            configureOptions(binderOptions);
        
            if (binderOptions.BindNonPublicProperties)
            {
                throw new NotSupportedException($"The configuration binding source generator does not support 'BinderOptions.BindNonPublicProperties'.");
            }
        
            return binderOptions;
        }
 
        public static int ParseInt(string value, Func<string?> getPath)
        {
            try
            {
                return int.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture);
            }
            catch (Exception exception)
            {
                throw new InvalidOperationException($"Failed to convert configuration value at '{getPath()}' to type '{typeof(int)}'.", exception);
            }
        }
 
        public static global::System.TimeSpan ParseSystemTimeSpan(string value, Func<string?> getPath)
        {
            try
            {
                return global::System.TimeSpan.Parse(value, CultureInfo.InvariantCulture);
            }
            catch (Exception exception)
            {
                throw new InvalidOperationException($"Failed to convert configuration value at '{getPath()}' to type '{typeof(global::System.TimeSpan)}'.", exception);
            }
        }
        #endregion Core binding extensions.
    }
}