using Microsoft.Extensions.Options;

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

/// <summary>
/// Regression: <see cref="CommunicationOptions"/> timeouts feed per-pattern Ask
/// deadlines and gRPC keepalive/stream-lifetime settings; a zero/negative value
/// (or a non-positive <c>GrpcMaxConcurrentStreams</c>) must be rejected at startup
/// by an <see cref="IValidateOptions{TOptions}"/> with a clear, key-naming message
/// rather than surfacing at first Ask/gRPC use.
/// </summary>
public class CommunicationOptionsValidatorTests
{
    private static ValidateOptionsResult Validate(CommunicationOptions options) =>
        new CommunicationOptionsValidator().Validate(Options.DefaultName, options);

    [Fact]
    public void DefaultOptions_AreValid()
    {
        var result = Validate(new CommunicationOptions());
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    [Fact]
    public void ZeroDeploymentTimeout_IsRejected()
    {
        var result = Validate(new CommunicationOptions { DeploymentTimeout = TimeSpan.Zero });
        Assert.True(result.Failed);
        Assert.Contains("DeploymentTimeout", result.FailureMessage);
    }

    // ── Audit-ingest timeout ladder (arch-review phase-2 residual #2) ────────────

    [Fact]
    public void TheAuditIngestTimeoutLadder_IsStrictlyMonotonic_EndToEnd()
    {
        // 35 (site forward Ask) > 30 (gRPC deadline AND central's Ask of the ingest singleton)
        // > 20 (actor budget) > 15 (SQL command). Ties are the bug this closes: the site Ask
        // used to reuse NotificationForwardTimeout (30 s), so a slow-but-succeeding central
        // write could be acked to a caller that had already given up and re-sent the batch.
        var options = new CommunicationOptions();

        Assert.Equal(TimeSpan.FromSeconds(35), options.AuditForwardTimeout);
        Assert.True(options.AuditForwardTimeout > ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteStreamGrpcServer.AuditIngestAskTimeout);
        Assert.Equal(TimeSpan.FromSeconds(30), ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteStreamGrpcServer.AuditIngestAskTimeout);
    }

    [Fact]
    public void AuditForwardTimeout_EqualToTheAskTimeout_IsRejected()
    {
        // Equality is precisely the pre-fix state, so the validator must refuse it, not just
        // refuse something smaller.
        var result = Validate(new CommunicationOptions
        {
            AuditForwardTimeout = ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteStreamGrpcServer.AuditIngestAskTimeout,
        });

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

    [Fact]
    public void AuditForwardTimeout_ShorterThanTheAskTimeout_IsRejected()
    {
        var result = Validate(new CommunicationOptions
        {
            AuditForwardTimeout = TimeSpan.FromSeconds(5),
        });

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

    [Fact]
    public void AuditForwardTimeout_IsStillConfigurableUpwards()
    {
        var result = Validate(new CommunicationOptions
        {
            AuditForwardTimeout = TimeSpan.FromMinutes(2),
        });

        Assert.True(result.Succeeded, result.FailureMessage);
    }

    [Fact]
    public void NonPositiveGrpcMaxConcurrentStreams_IsRejected()
    {
        var result = Validate(new CommunicationOptions { GrpcMaxConcurrentStreams = 0 });
        Assert.True(result.Failed);
        Assert.Contains("GrpcMaxConcurrentStreams", result.FailureMessage);
    }

    // ── Aggregated live alarm cache options (plan #10, Task 6) ───────────────────

    [Fact]
    public void ZeroLiveAlarmCacheLinger_IsValid()
    {
        // Zero linger = stop the aggregator immediately when the last viewer leaves.
        var result = Validate(new CommunicationOptions { LiveAlarmCacheLinger = TimeSpan.Zero });
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    [Fact]
    public void NegativeLiveAlarmCacheLinger_IsRejected()
    {
        var result = Validate(new CommunicationOptions { LiveAlarmCacheLinger = TimeSpan.FromSeconds(-1) });
        Assert.True(result.Failed);
        Assert.Contains("LiveAlarmCacheLinger", result.FailureMessage);
    }

    [Fact]
    public void ZeroLiveAlarmCacheReconcileInterval_IsRejected()
    {
        var result = Validate(new CommunicationOptions { LiveAlarmCacheReconcileInterval = TimeSpan.Zero });
        Assert.True(result.Failed);
        Assert.Contains("LiveAlarmCacheReconcileInterval", result.FailureMessage);
    }

    [Fact]
    public void ZeroLiveAlarmCacheSeedConcurrency_IsRejected()
    {
        var result = Validate(new CommunicationOptions { LiveAlarmCacheSeedConcurrency = 0 });
        Assert.True(result.Failed);
        Assert.Contains("LiveAlarmCacheSeedConcurrency", result.FailureMessage);
    }

    [Fact]
    public void ExcessiveLiveAlarmCacheSeedConcurrency_IsRejected()
    {
        var result = Validate(new CommunicationOptions { LiveAlarmCacheSeedConcurrency = 65 });
        Assert.True(result.Failed);
        Assert.Contains("LiveAlarmCacheSeedConcurrency", result.FailureMessage);
    }

    [Fact]
    public void ZeroLiveAlarmCacheMaxSubscribersPerSite_IsRejected()
    {
        var result = Validate(new CommunicationOptions { LiveAlarmCacheMaxSubscribersPerSite = 0 });
        Assert.True(result.Failed);
        Assert.Contains("LiveAlarmCacheMaxSubscribersPerSite", result.FailureMessage);
    }

    // ── R2 T10: live-delta publish-coalescing window (N6) ────────────────────────

    [Fact]
    public void ZeroLiveAlarmCachePublishCoalesce_IsValid()
    {
        // Zero = publish per delta (legacy behavior).
        var result = Validate(new CommunicationOptions { LiveAlarmCachePublishCoalesce = TimeSpan.Zero });
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    [Fact]
    public void NegativeLiveAlarmCachePublishCoalesce_IsRejected()
    {
        var result = Validate(new CommunicationOptions { LiveAlarmCachePublishCoalesce = TimeSpan.FromMilliseconds(-1) });
        Assert.True(result.Failed);
        Assert.Contains("LiveAlarmCachePublishCoalesce", result.FailureMessage);
    }

    // ── gRPC central transport endpoints ─────────────────────────────────────────
    // gRPC (CentralControlService) is the only site→central transport after the
    // ClusterClient→gRPC migration's Phase 4. This role-agnostic validator only rejects BLANK
    // entries; an EMPTY list is valid (central nodes legitimately declare none). The role-aware
    // "a Site must list at least one endpoint" rule lives in StartupValidator, tested there.

    [Fact]
    public void EmptyEndpoints_IsValid()
    {
        // A central node hosts CentralControlService; it does not dial it, so it declares none.
        var result = Validate(new CommunicationOptions
        {
            CentralGrpcEndpoints = new List<string>(),
        });
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    [Fact]
    public void BlankEndpoint_IsRejected()
    {
        var result = Validate(new CommunicationOptions
        {
            CentralGrpcEndpoints = new List<string> { "   " },
        });
        Assert.True(result.Failed);
        Assert.Contains("CentralGrpcEndpoints", result.FailureMessage);
    }

    [Fact]
    public void Endpoints_IsValid()
    {
        var result = Validate(new CommunicationOptions
        {
            CentralGrpcEndpoints = new List<string>
            {
                "http://scadabridge-central-a:8083",
                "http://scadabridge-central-b:8083",
            },
        });
        Assert.True(result.Succeeded, result.FailureMessage);
    }
}
