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: malformed <c>--bindings</c> / <c>--overrides</c> JSON
/// previously threw unhandled exceptions instead of producing a clean validation error.
/// </summary>
public class InstanceArgumentParsingTests
{
    /// <summary>Verifies that valid bindings JSON is parsed into attribute and connection id pairs.</summary>
    [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]);
    }

    /// <summary>Verifies that malformed bindings JSON yields an error message instead of throwing an exception.</summary>
    [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);
    }

    /// <summary>Verifies that a binding pair with too few elements yields an error instead of throwing.</summary>
    [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);
    }

    /// <summary>Verifies that binding elements of the wrong JSON types yield an error instead of throwing.</summary>
    [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);
    }

    /// <summary>Verifies that a bindings document of JSON null yields an error instead of throwing.</summary>
    [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);
    }

    /// <summary>Verifies that the optional third binding element is captured as a data source reference override.</summary>
    [Fact]
    public void ParseBindings_ThreeElementForm_CapturesReferenceOverride()
    {
        // The optional 3rd element carries the per-instance data-source reference
        // override 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);
    }

    /// <summary>Verifies that an explicit null third element leaves the reference override unset.</summary>
    [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);
    }

    /// <summary>Verifies that a third binding element of the wrong type yields an error instead of throwing.</summary>
    [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);
    }

    /// <summary>Verifies that a binding with four elements yields an error instead of throwing.</summary>
    [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);
    }

    /// <summary>Verifies that valid overrides JSON is parsed into a dictionary.</summary>
    [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"]);
    }

    /// <summary>Verifies that malformed overrides JSON yields an error instead of throwing.</summary>
    [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);
    }

    /// <summary>Verifies that an overrides document of JSON null yields an error instead of throwing.</summary>
    [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) ---

    /// <summary>Verifies that a module rewrite changes only the named module's bindings and applies the requested connection.</summary>
    [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"));
    }

    /// <summary>Verifies that the instance-level group matches attribute names that contain no dot.</summary>
    [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);
    }

    /// <summary>Verifies that an empty object path clears the data source reference override.</summary>
    [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);
    }

    /// <summary>Verifies that surrounding whitespace and a trailing dot on the object path are trimmed.</summary>
    [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);
    }

    /// <summary>Verifies that an unknown module name produces an error listing the available modules.</summary>
    [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);
    }

    /// <summary>Verifies that existing bindings are read from camelCase instance JSON.</summary>
    [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]);
    }

    /// <summary>Verifies that instance JSON without a bindings array yields an empty list.</summary>
    [Fact]
    public void ParseExistingBindings_MissingArray_ReturnsEmpty()
    {
        Assert.Empty(InstanceCommands.ParseExistingBindings("""{"id":7}"""));
        Assert.Empty(InstanceCommands.ParseExistingBindings("""{"id":7,"connectionBindings":null}"""));
    }

    /// <summary>Verifies that the bind-module command parses its options and rejects a missing object path.</summary>
    [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);
    }
}