ScadaBridge/tests/ZB.MOM.WW.ScadaBridge.CLI.Tests/InstanceArgumentParsingTests.cs

using System.CommandLine;
using ZB.MOM.WW.ScadaBridge.CLI.Commands;
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;

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

/// <summary>
/// Regression tests for CLI-005 — malformed <c>--bindings</c> / <c>--overrides</c> JSON
/// previously threw unhandled exceptions instead of producing a clean validation error.
/// </summary>
public class InstanceArgumentParsingTests
{
    [Fact]
    public void ParseBindings_ValidJson_ReturnsPairs()
    {
        var ok = InstanceCommands.TryParseBindings(
            "[[\"Speed\", 5], [\"Mode\", 7]]", out var bindings, out var error);

        Assert.True(ok);
        Assert.Null(error);
        Assert.Equal(2, bindings!.Count);
        Assert.Equal(new ConnectionBinding("Speed", 5), bindings[0]);
        Assert.Equal(new ConnectionBinding("Mode", 7), bindings[1]);
    }

    [Fact]
    public void ParseBindings_MalformedJson_ReturnsErrorNotException()
    {
        var ok = InstanceCommands.TryParseBindings("not json", out var bindings, out var error);

        Assert.False(ok);
        Assert.Null(bindings);
        Assert.NotNull(error);
    }

    [Fact]
    public void ParseBindings_ShortPair_ReturnsErrorNotException()
    {
        // A pair with fewer than two elements previously threw ArgumentOutOfRangeException.
        var ok = InstanceCommands.TryParseBindings("[[\"Speed\"]]", out var bindings, out var error);

        Assert.False(ok);
        Assert.Null(bindings);
        Assert.NotNull(error);
    }

    [Fact]
    public void ParseBindings_WrongElementTypes_ReturnsErrorNotException()
    {
        // A non-string name / non-int id previously threw InvalidOperationException.
        var ok = InstanceCommands.TryParseBindings("[[5, \"Speed\"]]", out var bindings, out var error);

        Assert.False(ok);
        Assert.Null(bindings);
        Assert.NotNull(error);
    }

    [Fact]
    public void ParseBindings_JsonNull_ReturnsErrorNotException()
    {
        var ok = InstanceCommands.TryParseBindings("null", out var bindings, out var error);

        Assert.False(ok);
        Assert.Null(bindings);
        Assert.NotNull(error);
    }

    [Fact]
    public void ParseBindings_ThreeElementForm_CapturesReferenceOverride()
    {
        // The optional 3rd element carries the per-instance data-source reference
        // override (followup #4) so the CLI can SET it instead of always wiping it.
        var ok = InstanceCommands.TryParseBindings(
            "[[\"Speed\", 5, \"ns=2;s=Spd\"], [\"Mode\", 7]]", out var bindings, out var error);

        Assert.True(ok);
        Assert.Null(error);
        Assert.Equal(2, bindings!.Count);
        Assert.Equal(new ConnectionBinding("Speed", 5, "ns=2;s=Spd"), bindings[0]);
        // A 2-element entry still leaves the override null (template default applies).
        Assert.Equal(new ConnectionBinding("Mode", 7, null), bindings[1]);
        Assert.Null(bindings[1].DataSourceReferenceOverride);
    }

    [Fact]
    public void ParseBindings_ThirdElementExplicitNull_LeavesOverrideUnset()
    {
        var ok = InstanceCommands.TryParseBindings(
            "[[\"Speed\", 5, null]]", out var bindings, out var error);

        Assert.True(ok);
        Assert.Null(error);
        Assert.Single(bindings!);
        Assert.Null(bindings![0].DataSourceReferenceOverride);
    }

    [Fact]
    public void ParseBindings_ThirdElementWrongType_ReturnsErrorNotException()
    {
        // A non-string, non-null 3rd element is rejected with a clean error.
        var ok = InstanceCommands.TryParseBindings(
            "[[\"Speed\", 5, 99]]", out var bindings, out var error);

        Assert.False(ok);
        Assert.Null(bindings);
        Assert.NotNull(error);
    }

    [Fact]
    public void ParseBindings_FourElements_ReturnsErrorNotException()
    {
        var ok = InstanceCommands.TryParseBindings(
            "[[\"Speed\", 5, \"ref\", \"extra\"]]", out var bindings, out var error);

        Assert.False(ok);
        Assert.Null(bindings);
        Assert.NotNull(error);
    }

    [Fact]
    public void ParseOverrides_ValidJson_ReturnsDictionary()
    {
        var ok = InstanceCommands.TryParseOverrides(
            "{\"Speed\": \"100\", \"Mode\": null}", out var overrides, out var error);

        Assert.True(ok);
        Assert.Null(error);
        Assert.Equal(2, overrides!.Count);
        Assert.Equal("100", overrides["Speed"]);
        Assert.Null(overrides["Mode"]);
    }

    [Fact]
    public void ParseOverrides_MalformedJson_ReturnsErrorNotException()
    {
        var ok = InstanceCommands.TryParseOverrides("{bad json", out var overrides, out var error);

        Assert.False(ok);
        Assert.Null(overrides);
        Assert.NotNull(error);
    }

    [Fact]
    public void ParseOverrides_JsonNull_ReturnsErrorNotException()
    {
        var ok = InstanceCommands.TryParseOverrides("null", out var overrides, out var error);

        Assert.False(ok);
        Assert.Null(overrides);
        Assert.NotNull(error);
    }

    // --- instance bind-module (grouped connection bindings, 2026-08-20) ---

    [Fact]
    public void BuildModuleRewrite_RewritesOnlyTheModule_AndKeepsConnection()
    {
        var existing = new[]
        {
            new ConnectionBinding("RightMESReceiver.MoveInFlag", 1, "MESReceiver_024.MoveInFlag"),
            new ConnectionBinding("RightMESReceiver.ScanStateCmd", 1, "MESReceiver_024.ScanStateCmd"),
            new ConnectionBinding("LeftMESReceiver.MoveInFlag", 1, "MESReceiver_023.MoveInFlag"),
        };
        var ok = InstanceCommands.BuildModuleRewrite(existing, "RightMESReceiver", connectionId: 1, objectPath: "MESReceiver_022", out var rewritten, out var error);
        Assert.True(ok, error);
        Assert.Equal(2, rewritten!.Count);
        Assert.All(rewritten, b => Assert.StartsWith("MESReceiver_022.", b.DataSourceReferenceOverride!));
        Assert.Contains(rewritten, b => b.AttributeName == "RightMESReceiver.MoveInFlag" && b.DataSourceReferenceOverride == "MESReceiver_022.MoveInFlag");
        Assert.DoesNotContain(rewritten, b => b.AttributeName.StartsWith("Left"));
    }

    [Fact]
    public void BuildModuleRewrite_InstanceGroup_MatchesDotlessNames()
    {
        var existing = new[] { new ConnectionBinding("ChlorineFlow", 1, "Z28061.ChlorineFlow"), new ConnectionBinding("M.A", 1, "O.A") };
        Assert.True(InstanceCommands.BuildModuleRewrite(existing, "(instance)", 1, "Z28063", out var r, out _));
        var b = Assert.Single(r!);
        Assert.Equal("Z28063.ChlorineFlow", b.DataSourceReferenceOverride);
    }

    [Fact]
    public void BuildModuleRewrite_EmptyObject_ClearsOverride()
    {
        var existing = new[] { new ConnectionBinding("M.A", 1, "O.A") };
        Assert.True(InstanceCommands.BuildModuleRewrite(existing, "M", 2, "", out var r, out _));
        var b = Assert.Single(r!);
        Assert.Null(b.DataSourceReferenceOverride);
        Assert.Equal(2, b.DataConnectionId);
    }

    [Fact]
    public void BuildModuleRewrite_TrailingDotOnObject_IsTrimmed()
    {
        var existing = new[] { new ConnectionBinding("M.A", 1, "O.A") };
        Assert.True(InstanceCommands.BuildModuleRewrite(existing, "M", 1, " X. ", out var r, out _));
        Assert.Equal("X.A", Assert.Single(r!).DataSourceReferenceOverride);
    }

    [Fact]
    public void BuildModuleRewrite_UnknownModule_ListsAvailable()
    {
        var existing = new[] { new ConnectionBinding("M.A", 1, "O.A"), new ConnectionBinding("N.B", 1, "O.B"), new ConnectionBinding("Direct", 1, null) };
        Assert.False(InstanceCommands.BuildModuleRewrite(existing, "Q", 1, "X", out var rewritten, out var error));
        Assert.Null(rewritten);
        Assert.Contains("M", error);
        Assert.Contains("N", error);
        Assert.Contains("(instance)", error);
    }

    [Fact]
    public void ParseExistingBindings_ReadsCamelCaseInstanceJson()
    {
        const string json = """
            {"id":7,"uniqueName":"X","connectionBindings":[
              {"id":1,"instanceId":7,"attributeName":"M.A","dataConnectionId":3,"dataSourceReferenceOverride":"O.A"},
              {"id":2,"instanceId":7,"attributeName":"Direct","dataConnectionId":4,"dataSourceReferenceOverride":null},
              {"id":3,"instanceId":7,"attributeName":"NoOverrideProp","dataConnectionId":5}
            ]}
            """;
        var bindings = InstanceCommands.ParseExistingBindings(json);
        Assert.Equal(3, bindings.Count);
        Assert.Equal(new ConnectionBinding("M.A", 3, "O.A"), bindings[0]);
        Assert.Equal(new ConnectionBinding("Direct", 4), bindings[1]);
        Assert.Equal(new ConnectionBinding("NoOverrideProp", 5), bindings[2]);
    }

    [Fact]
    public void ParseExistingBindings_MissingArray_ReturnsEmpty()
    {
        Assert.Empty(InstanceCommands.ParseExistingBindings("""{"id":7}"""));
        Assert.Empty(InstanceCommands.ParseExistingBindings("""{"id":7,"connectionBindings":null}"""));
    }

    [Fact]
    public void BindModule_ParsesOptions()
    {
        var instance = InstanceCommands.Build(
            new Option<string>("--url"), new Option<string>("--format"),
            new Option<string>("--username"), new Option<string>("--password"));
        var bindModule = instance.Subcommands.Single(c => c.Name == "bind-module");
        var result = bindModule.Parse(["--id", "1", "--module", "RightMESReceiver", "--connection", "1", "--object", "MESReceiver_022", "--dry-run"]);
        Assert.Empty(result.Errors);

        var missingObject = bindModule.Parse(["--id", "1", "--module", "M", "--connection", "1"]);
        Assert.NotEmpty(missingObject.Errors);
    }
}