using Microsoft.Extensions.Options;

namespace ZB.MOM.WW.ScadaBridge.InboundAPI.Tests;

/// <summary>
/// Arch-review 08 §1.5: <see cref="InboundApiOptions"/> feeds a per-request timeout
/// (<see cref="InboundApiOptions.DefaultMethodTimeout"/>) and a body-size cap
/// (<see cref="InboundApiOptions.MaxRequestBodyBytes"/>) into the inbound-API request
/// pipeline; a zero/negative timeout or a non-positive body cap must be rejected fast at
/// startup with a clear, key-naming message rather than silently degrading the endpoint.
/// The <see cref="InboundApiOptions.ApiKeyPepper"/> is deliberately NOT required non-empty
/// here (empty is a legitimate dev default; production pepper strength is enforced elsewhere).
/// </summary>
public class InboundApiOptionsValidatorTests
{
    private static ValidateOptionsResult Validate(InboundApiOptions options) =>
        new InboundApiOptionsValidator().Validate(Options.DefaultName, options);

    /// <summary>Verifies that the default options are valid.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void DefaultOptions_AreValid()
    {
        var result = Validate(new InboundApiOptions());
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    /// <summary>Verifies that an empty API key pepper is valid.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void EmptyApiKeyPepper_IsValid()
    {
        var result = Validate(new InboundApiOptions { ApiKeyPepper = string.Empty });
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    /// <summary>Verifies that a zero default method timeout is rejected.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void ZeroDefaultMethodTimeout_IsRejected()
    {
        var result = Validate(new InboundApiOptions { DefaultMethodTimeout = TimeSpan.Zero });

        Assert.True(result.Failed);
        Assert.Contains("DefaultMethodTimeout", result.FailureMessage);
    }

    /// <summary>Verifies that a negative default method timeout is rejected.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void NegativeDefaultMethodTimeout_IsRejected()
    {
        var result = Validate(new InboundApiOptions { DefaultMethodTimeout = TimeSpan.FromSeconds(-1) });

        Assert.True(result.Failed);
        Assert.Contains("DefaultMethodTimeout", result.FailureMessage);
    }

    /// <summary>Verifies that a zero maximum request body size is rejected.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void ZeroMaxRequestBodyBytes_IsRejected()
    {
        var result = Validate(new InboundApiOptions { MaxRequestBodyBytes = 0 });

        Assert.True(result.Failed);
        Assert.Contains("MaxRequestBodyBytes", result.FailureMessage);
    }

    /// <summary>Verifies that a negative maximum request body size is rejected.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void NegativeMaxRequestBodyBytes_IsRejected()
    {
        var result = Validate(new InboundApiOptions { MaxRequestBodyBytes = -1 });

        Assert.True(result.Failed);
        Assert.Contains("MaxRequestBodyBytes", result.FailureMessage);
    }

    /// <summary>Verifies that a zero API method cache TTL is rejected.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void ZeroApiMethodCacheTtl_IsRejected()
    {
        var result = Validate(new InboundApiOptions { ApiMethodCacheTtl = TimeSpan.Zero });

        Assert.True(result.Failed);
        Assert.Contains("ApiMethodCacheTtl", result.FailureMessage);
    }

    /// <summary>Verifies that a negative API method cache TTL is rejected.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void NegativeApiMethodCacheTtl_IsRejected()
    {
        var result = Validate(new InboundApiOptions { ApiMethodCacheTtl = TimeSpan.FromSeconds(-1) });

        Assert.True(result.Failed);
        Assert.Contains("ApiMethodCacheTtl", result.FailureMessage);
    }

    // --- Standby forwarding (2026-08-28) ---

    /// <summary>Verifies that absolute HTTP URLs are valid standby forward peer endpoints.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void StandbyForwardPeerEndpoints_AbsoluteHttpUrls_AreValid()
    {
        var result = Validate(new InboundApiOptions
        {
            StandbyForwardPeerEndpoints = { "http://central-b:5000", "https://central-b.example/" },
        });
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    /// <summary>Verifies that non-HTTP or relative standby forward peer endpoints are rejected.</summary>
    /// <param name="peer">The peer.</param>
    /// <returns>The result.</returns>
    [Theory]
    [InlineData("central-b:5000")]
    [InlineData("/api")]
    [InlineData("ftp://central-b")]
    [InlineData("")]
    public void StandbyForwardPeerEndpoints_NonHttpOrRelative_IsRejected(string peer)
    {
        var result = Validate(new InboundApiOptions { StandbyForwardPeerEndpoints = { peer } });

        Assert.True(result.Failed);
        Assert.Contains("StandbyForwardPeerEndpoints", result.FailureMessage);
    }

    /// <summary>Verifies that a zero standby forward timeout is rejected.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void ZeroStandbyForwardTimeout_IsRejected()
    {
        var result = Validate(new InboundApiOptions { StandbyForwardTimeout = TimeSpan.Zero });

        Assert.True(result.Failed);
        Assert.Contains("StandbyForwardTimeout", result.FailureMessage);
    }

    // --- Flow Debugger step logs (design 2026-09-09 D7) ---

    /// <summary>Verifies that a non-positive maximum log line count per run is rejected.</summary>
    /// <param name="max">The max.</param>
    /// <returns>The result.</returns>
    [Theory]
    [InlineData(0)]
    [InlineData(-1)]
    public void NonPositiveMaxLogLinesPerRun_IsRejected(int max)
    {
        // A zero/negative cap would audit no line of a traced run at all while still
        // paying for the closing "dropped" row - the option must bound, not disable.
        var result = Validate(new InboundApiOptions { MaxLogLinesPerRun = max });

        Assert.True(result.Failed);
        Assert.Contains("MaxLogLinesPerRun", result.FailureMessage);
    }
}