using Microsoft.Extensions.Options;

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

/// <summary>
/// Arch-review 08 §1.5: <see cref="DeploymentManagerOptions"/> timeouts are
/// applied as linked-CTS deadlines around lifecycle commands, per-site artifact
/// deployment, and operation-lock acquisition. A zero/negative duration makes a
/// deadline fire immediately (or a <c>CancellationTokenSource</c> constructor
/// throw), so a misconfigured section must be rejected at startup with a clear,
/// key-naming message rather than silently breaking deployments.
/// </summary>
public class DeploymentManagerOptionsValidatorTests
{
    private static ValidateOptionsResult Validate(DeploymentManagerOptions options) =>
        new DeploymentManagerOptionsValidator().Validate(Options.DefaultName, options);

    /// <summary>Verifies that the default options pass validation.</summary>
    [Fact]
    public void DefaultOptions_AreValid()
    {
        var result = Validate(new DeploymentManagerOptions());
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    /// <summary>Verifies that a zero lifecycle command timeout is rejected.</summary>
    [Fact]
    public void ZeroLifecycleCommandTimeout_IsRejected()
    {
        var result = Validate(new DeploymentManagerOptions { LifecycleCommandTimeout = TimeSpan.Zero });
        Assert.True(result.Failed);
        Assert.Contains("LifecycleCommandTimeout", result.FailureMessage);
    }

    /// <summary>Verifies that a negative lifecycle command timeout is rejected.</summary>
    [Fact]
    public void NegativeLifecycleCommandTimeout_IsRejected()
    {
        var result = Validate(new DeploymentManagerOptions { LifecycleCommandTimeout = TimeSpan.FromSeconds(-1) });
        Assert.True(result.Failed);
        Assert.Contains("LifecycleCommandTimeout", result.FailureMessage);
    }

    /// <summary>Verifies that a zero per-site artifact deployment timeout is rejected.</summary>
    [Fact]
    public void ZeroArtifactDeploymentTimeoutPerSite_IsRejected()
    {
        var result = Validate(new DeploymentManagerOptions { ArtifactDeploymentTimeoutPerSite = TimeSpan.Zero });
        Assert.True(result.Failed);
        Assert.Contains("ArtifactDeploymentTimeoutPerSite", result.FailureMessage);
    }

    /// <summary>Verifies that a zero operation lock timeout is rejected.</summary>
    [Fact]
    public void ZeroOperationLockTimeout_IsRejected()
    {
        var result = Validate(new DeploymentManagerOptions { OperationLockTimeout = TimeSpan.Zero });
        Assert.True(result.Failed);
        Assert.Contains("OperationLockTimeout", result.FailureMessage);
    }

    /// <summary>Verifies that a zero site deployment reconcile timeout is rejected.</summary>
    [Fact]
    public void ZeroSiteDeploymentReconcileTimeout_IsRejected()
    {
        var result = Validate(new DeploymentManagerOptions { SiteDeploymentReconcileTimeout = TimeSpan.Zero });
        Assert.True(result.Failed);
        Assert.Contains("SiteDeploymentReconcileTimeout", result.FailureMessage);
    }

    /// <summary>Verifies that a negative site deployment reconcile timeout is rejected.</summary>
    [Fact]
    public void NegativeSiteDeploymentReconcileTimeout_IsRejected()
    {
        var result = Validate(new DeploymentManagerOptions
        {
            SiteDeploymentReconcileTimeout = TimeSpan.FromSeconds(-1)
        });
        Assert.True(result.Failed);
        Assert.Contains("SiteDeploymentReconcileTimeout", result.FailureMessage);
    }

    /// <summary>Verifies that a zero pending-updates cache TTL is rejected.</summary>
    [Fact]
    public void ZeroPendingUpdatesCacheTtl_IsRejected()
    {
        // A zero TTL makes every Deployer/Administrator circuit's poll a cache miss,
        // so the whole fleet is re-flattened on each one — the exact cost the cache
        // exists to avoid.
        var result = Validate(new DeploymentManagerOptions { PendingUpdatesCacheTtl = TimeSpan.Zero });
        Assert.True(result.Failed);
        Assert.Contains("PendingUpdatesCacheTtl", result.FailureMessage);
    }

    /// <summary>Verifies that a negative pending-updates cache TTL is rejected.</summary>
    [Fact]
    public void NegativePendingUpdatesCacheTtl_IsRejected()
    {
        var result = Validate(new DeploymentManagerOptions
        {
            PendingUpdatesCacheTtl = TimeSpan.FromSeconds(-1)
        });
        Assert.True(result.Failed);
        Assert.Contains("PendingUpdatesCacheTtl", result.FailureMessage);
    }
}