using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using Shouldly;
using Xunit;
using ZB.MOM.WW.Configuration;
using ZB.MOM.WW.OtOpcUa.Host.Configuration;
using ZB.MOM.WW.OtOpcUa.Runtime.Historian;

namespace ZB.MOM.WW.OtOpcUa.Host.IntegrationTests;

/// <summary>
/// archreview 06/S-11 — verifies the net-new <see cref="ServerHistorianOptionsValidator"/> (built on
/// the shared <c>ZB.MOM.WW.Configuration</c> <c>OptionsValidatorBase</c>/<c>ValidationBuilder</c>).
/// The fail tier is deliberately narrow: only <b>provably-crashing</b> configs fail — an enabled
/// historian (or an enabled <c>AlarmHistorian</c>, which sources its gateway connection from the
/// <c>ServerHistorian</c> section) with an empty / non-absolute / non-http(s) <c>Endpoint</c>, i.e.
/// exactly the configs that would otherwise throw <see cref="System.UriFormatException"/> deep in the
/// gateway client factory at startup. Empty <c>ApiKey</c> / non-positive <c>MaxTieClusterOverfetch</c>
/// stay operator warnings in <see cref="ServerHistorianOptions.Validate"/> (they degrade, not crash).
/// </summary>
public sealed class ServerHistorianOptionsValidatorTests
{
    private static ServerHistorianOptionsValidator Sut(bool alarmHistorianEnabled = false)
    {
        var configuration = new ConfigurationBuilder()
            .AddInMemoryCollection(new Dictionary<string, string?>
            {
                ["AlarmHistorian:Enabled"] = alarmHistorianEnabled ? "true" : "false",
            })
            .Build();
        return new ServerHistorianOptionsValidator(configuration);
    }

    /// <summary>Enabled historian with an empty endpoint fails (would crash-loop in the factory).</summary>
    [Fact]
    public void Enabled_with_empty_endpoint_fails()
    {
        var result = Sut().Validate(null, new ServerHistorianOptions { Enabled = true, Endpoint = "" });

        result.Failed.ShouldBeTrue();
        result.Failures.ShouldContain(f => f.Contains("ServerHistorian:Endpoint"));
    }

    /// <summary>Enabled with a relative (non-absolute) URI fails.</summary>
    [Fact]
    public void Enabled_with_relative_uri_fails()
    {
        var result = Sut().Validate(null, new ServerHistorianOptions { Enabled = true, Endpoint = "host:5222" });

        result.Failed.ShouldBeTrue();
        result.Failures.ShouldContain(f => f.Contains("ServerHistorian:Endpoint"));
    }

    /// <summary>Enabled with a non-http(s) scheme (ftp) fails.</summary>
    [Fact]
    public void Enabled_with_bad_scheme_fails()
    {
        var result = Sut().Validate(null, new ServerHistorianOptions { Enabled = true, Endpoint = "ftp://host:5222" });

        result.Failed.ShouldBeTrue();
        result.Failures.ShouldContain(f => f.Contains("ServerHistorian:Endpoint"));
    }

    /// <summary>Enabled with a valid absolute https endpoint succeeds.</summary>
    [Fact]
    public void Enabled_with_valid_https_endpoint_succeeds()
    {
        var result = Sut().Validate(null, new ServerHistorianOptions { Enabled = true, Endpoint = "https://host:5222" });

        result.Succeeded.ShouldBeTrue();
    }

    /// <summary>A disabled section may legitimately be empty — no failure.</summary>
    [Fact]
    public void Disabled_with_empty_endpoint_succeeds()
    {
        var result = Sut().Validate(null, new ServerHistorianOptions { Enabled = false, Endpoint = "" });

        result.Succeeded.ShouldBeTrue();
    }

    /// <summary>
    /// The residual corner: <c>ServerHistorian:Enabled=false</c> but <c>AlarmHistorian:Enabled=true</c>
    /// (which sources its connection from the ServerHistorian section) with an empty endpoint fails —
    /// and the message names BOTH sections so the operator understands why a disabled section is required.
    /// </summary>
    [Fact]
    public void Disabled_but_alarm_historian_enabled_with_empty_endpoint_fails_naming_both_sections()
    {
        var result = Sut(alarmHistorianEnabled: true)
            .Validate(null, new ServerHistorianOptions { Enabled = false, Endpoint = "" });

        result.Failed.ShouldBeTrue();
        result.Failures.ShouldContain(f =>
            f.Contains("ServerHistorian:Endpoint") && f.Contains("AlarmHistorian:Enabled"));
    }

    /// <summary>Alarm-only mode with a valid endpoint succeeds.</summary>
    [Fact]
    public void Disabled_but_alarm_historian_enabled_with_valid_endpoint_succeeds()
    {
        var result = Sut(alarmHistorianEnabled: true)
            .Validate(null, new ServerHistorianOptions { Enabled = false, Endpoint = "https://host:5222" });

        result.Succeeded.ShouldBeTrue();
    }

    /// <summary>
    /// Wiring guard (the "register-AND-consume" trap): resolving <c>IOptions&lt;ServerHistorianOptions&gt;.Value</c>
    /// after <see cref="ServiceCollectionExtensions.AddValidatedOptions{TOptions,TValidator}"/> throws
    /// <see cref="OptionsValidationException"/> for an enabled+empty section — proving the validator is
    /// attached to the options pipeline (not merely defined). <c>ValidateOnStart</c> reaching host start
    /// is already proven by the LDAP precedent.
    /// </summary>
    [Fact]
    public void AddValidatedOptions_wiring_throws_on_enabled_empty_endpoint()
    {
        var configuration = new ConfigurationBuilder()
            .AddInMemoryCollection(new Dictionary<string, string?>
            {
                ["ServerHistorian:Enabled"] = "true",
                ["ServerHistorian:Endpoint"] = "",
            })
            .Build();

        var services = new ServiceCollection();
        services.AddSingleton<IConfiguration>(configuration);
        services.AddValidatedOptions<ServerHistorianOptions, ServerHistorianOptionsValidator>(
            configuration, ServerHistorianOptions.SectionName);
        using var provider = services.BuildServiceProvider();

        var ex = Should.Throw<OptionsValidationException>(
            () => _ = provider.GetRequiredService<IOptions<ServerHistorianOptions>>().Value);
        ex.Failures.ShouldContain(f => f.Contains("ServerHistorian:Endpoint"));
    }
}
