using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;

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

/// <summary>
/// Tests for the instance state transition matrix.
/// </summary>
public class StateTransitionValidatorTests
{
    // ── Deploy transitions ──

    /// <summary>Verifies that deploying is allowed from every instance state.</summary>
    /// <param name="state">The current instance state.</param>
    [Theory]
    [InlineData(InstanceState.NotDeployed)]
    [InlineData(InstanceState.Enabled)]
    [InlineData(InstanceState.Disabled)]
    public void CanDeploy_AllStates_ReturnsTrue(InstanceState state)
    {
        Assert.True(StateTransitionValidator.CanDeploy(state));
    }

    // ── Disable transitions ──

    /// <summary>Verifies that an enabled instance can be disabled.</summary>
    [Fact]
    public void CanDisable_WhenEnabled_ReturnsTrue()
    {
        Assert.True(StateTransitionValidator.CanDisable(InstanceState.Enabled));
    }

    /// <summary>Verifies that a disabled instance cannot be disabled again.</summary>
    [Fact]
    public void CanDisable_WhenDisabled_ReturnsFalse()
    {
        Assert.False(StateTransitionValidator.CanDisable(InstanceState.Disabled));
    }

    /// <summary>Verifies that a not-deployed instance cannot be disabled.</summary>
    [Fact]
    public void CanDisable_WhenNotDeployed_ReturnsFalse()
    {
        Assert.False(StateTransitionValidator.CanDisable(InstanceState.NotDeployed));
    }

    // ── Enable transitions ──

    /// <summary>Verifies that a disabled instance can be enabled.</summary>
    [Fact]
    public void CanEnable_WhenDisabled_ReturnsTrue()
    {
        Assert.True(StateTransitionValidator.CanEnable(InstanceState.Disabled));
    }

    /// <summary>Verifies that an enabled instance cannot be enabled again.</summary>
    [Fact]
    public void CanEnable_WhenEnabled_ReturnsFalse()
    {
        Assert.False(StateTransitionValidator.CanEnable(InstanceState.Enabled));
    }

    /// <summary>Verifies that a not-deployed instance cannot be enabled.</summary>
    [Fact]
    public void CanEnable_WhenNotDeployed_ReturnsFalse()
    {
        Assert.False(StateTransitionValidator.CanEnable(InstanceState.NotDeployed));
    }

    // ── Delete transitions ──

    /// <summary>Verifies that an enabled instance can be deleted.</summary>
    [Fact]
    public void CanDelete_WhenEnabled_ReturnsTrue()
    {
        Assert.True(StateTransitionValidator.CanDelete(InstanceState.Enabled));
    }

    /// <summary>Verifies that a disabled instance can be deleted.</summary>
    [Fact]
    public void CanDelete_WhenDisabled_ReturnsTrue()
    {
        Assert.True(StateTransitionValidator.CanDelete(InstanceState.Disabled));
    }

    /// <summary>Verifies that a not-deployed instance can be deleted.</summary>
    [Fact]
    public void CanDelete_WhenNotDeployed_ReturnsTrue()
    {
        Assert.True(StateTransitionValidator.CanDelete(InstanceState.NotDeployed));
    }

    // ── ValidateTransition ──

    /// <summary>Verifies that a valid deploy transition returns no error.</summary>
    [Fact]
    public void ValidateTransition_ValidDeploy_ReturnsNull()
    {
        var error = StateTransitionValidator.ValidateTransition(InstanceState.NotDeployed, "deploy");
        Assert.Null(error);
    }

    /// <summary>Verifies that an invalid enable transition returns an error.</summary>
    [Fact]
    public void ValidateTransition_InvalidEnable_ReturnsError()
    {
        var error = StateTransitionValidator.ValidateTransition(InstanceState.Enabled, "enable");
        Assert.NotNull(error);
        Assert.Contains("not allowed", error);
    }

    /// <summary>Verifies that an invalid disable transition returns an error.</summary>
    [Fact]
    public void ValidateTransition_InvalidDisable_ReturnsError()
    {
        var error = StateTransitionValidator.ValidateTransition(InstanceState.Disabled, "disable");
        Assert.NotNull(error);
    }

    /// <summary>Verifies that deleting a not-deployed instance returns no error.</summary>
    [Fact]
    public void ValidateTransition_ValidDeleteOnNotDeployed_ReturnsNull()
    {
        var error = StateTransitionValidator.ValidateTransition(InstanceState.NotDeployed, "delete");
        Assert.Null(error);
    }

    /// <summary>Verifies that an unknown operation returns an error.</summary>
    [Fact]
    public void ValidateTransition_UnknownOperation_ReturnsError()
    {
        var error = StateTransitionValidator.ValidateTransition(InstanceState.Enabled, "unknown");
        Assert.NotNull(error);
    }
}