using Shouldly;
using Xunit;

namespace ZB.MOM.WW.OtOpcUa.Driver.TwinCAT.Tests;

/// <summary>
///     Gitea #551: <see cref="TwinCATTagDefinitionFactory.Inspect"/> is <b>accept-gate-first</b> — it asks
///     <see cref="TwinCATTagDefinitionFactory.FromTagConfig"/> for the verdict and only explains a refusal.
///     See <c>ModbusInspectAcceptGateTests</c>'s remarks for why both directions (never stricter, never
///     silent) are pinned. TwinCAT's uncovered rejections were an absent <c>symbolPath</c> and the
///     unsupported <c>Structure</c> data type — a VALID enum name that the mapper still refuses.
/// </summary>
public sealed class TwinCATInspectAcceptGateTests
{
    private const string RawPath = "cell/twincat/dev1/T1";

    /// <summary>Blobs the mapper ACCEPTS — the gate must say nothing about any of them.</summary>
    public static TheoryData<string> Accepted() =>
    [
        """{"symbolPath":"MAIN.bStart","dataType":"Bool"}""",
        """{"symbolPath":"MAIN.nCount"}""",
        """{"symbolPath":"MAIN.aData","dataType":"DInt","isArray":true,"arrayLength":8}""",
        // A stale arrayLength behind a cleared isArray is scalar, not a rejection.
        """{"symbolPath":"MAIN.nCount","dataType":"DInt","arrayLength":8}""",
    ];

    /// <summary>Blobs the mapper REJECTS — the gate must produce at least one warning for each.</summary>
    public static TheoryData<string> Rejected() =>
    [
        """{"dataType":"Bool"}""",                              // no symbolPath
        """{"symbolPath":"","dataType":"Bool"}""",              // blank symbolPath
        """{"symbolPath":42}""",                                // symbolPath not a string
        """{"symbolPath":"MAIN.x","dataType":"Booll"}""",       // typo'd dataType
        """{"symbolPath":"MAIN.udt","dataType":"Structure"}""", // valid NAME the driver still refuses
    ];

    [Theory]
    [MemberData(nameof(Accepted))]
    public void A_config_the_mapper_accepts_draws_no_warning(string tagConfig)
    {
        TwinCATTagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeTrue("fixture must be accepted");
        TwinCATTagDefinitionFactory.Inspect(tagConfig).ShouldBeEmpty();
    }

    [Theory]
    [MemberData(nameof(Rejected))]
    public void A_config_the_mapper_rejects_is_never_passed_over_in_silence(string tagConfig)
    {
        TwinCATTagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeFalse("fixture must be rejected");
        TwinCATTagDefinitionFactory.Inspect(tagConfig).ShouldNotBeEmpty();
    }

    [Fact]
    public void An_absent_symbolPath_is_named()
        => TwinCATTagDefinitionFactory.Inspect("""{"dataType":"Bool"}""")
            .ShouldContain(w => w.Contains("'symbolPath'"));

    /// <summary>A rejection an enum-spelling check can never see: the NAME parses, the driver still refuses.</summary>
    [Fact]
    public void A_Structure_typed_tag_is_named()
        => TwinCATTagDefinitionFactory.Inspect("""{"symbolPath":"MAIN.udt","dataType":"Structure"}""")
            .ShouldContain(w => w.Contains("Structure"));

    [Fact]
    public void A_blank_reference_draws_nothing()
        => TwinCATTagDefinitionFactory.Inspect("   ").ShouldBeEmpty();

    [Fact]
    public void Unparseable_json_names_the_json()
        => TwinCATTagDefinitionFactory.Inspect("{oops").ShouldContain(w => w.Contains("not valid JSON"));

    // ---- Gitea #556 item 1: leading whitespace no longer defeats the framing pre-filter ----

    /// <summary>
    ///     Padding a blob with leading whitespace. A driver is handed whatever authoring persisted, and
    ///     <c>FromTagConfig</c> passes it straight to <c>JsonDocument.Parse</c>, which skips leading
    ///     whitespace — so the MAPPER's verdict is identical padded or not, and the gate's must be too.
    /// </summary>
    private const string Pad = " \t\r\n ";

    /// <summary>
    ///     Never stricter, under padding: a padded blob the mapper still accepts draws nothing. (This
    ///     direction already held before #556 — the pre-filter returned empty for everything padded — and
    ///     is kept so a future "just trim everywhere" change cannot start warning about a served tag.)
    /// </summary>
    /// <param name="tagConfig">An accepted fixture, padded below.</param>
    [Theory]
    [MemberData(nameof(Accepted))]
    public void Leading_whitespace_leaves_an_accepted_config_silent(string tagConfig)
    {
        var padded = Pad + tagConfig;
        TwinCATTagDefinitionFactory.FromTagConfig(padded, RawPath, out _)
            .ShouldBeTrue("the mapper's JsonDocument.Parse skips leading whitespace");
        TwinCATTagDefinitionFactory.Inspect(padded).ShouldBeEmpty();
    }

    /// <summary>
    ///     Never silent, under padding — the #556 item 1 defect itself. The pre-filter tested
    ///     <c>reference[0] != '{'</c>, so EVERY padded blob returned empty and a padded config the driver
    ///     refuses deployed clean. Asserting equality with the untrimmed inspection (rather than merely
    ///     "not empty") also pins that padding changes no message.
    /// </summary>
    /// <param name="tagConfig">A rejected fixture, padded below.</param>
    [Theory]
    [MemberData(nameof(Rejected))]
    public void Leading_whitespace_draws_exactly_the_warnings_the_untrimmed_blob_draws(string tagConfig)
    {
        var padded = Pad + tagConfig;
        TwinCATTagDefinitionFactory.FromTagConfig(padded, RawPath, out _)
            .ShouldBeFalse("the mapper's verdict is unchanged by padding");
        TwinCATTagDefinitionFactory.Inspect(padded).ShouldBe(TwinCATTagDefinitionFactory.Inspect(tagConfig));
    }

    /// <summary>
    ///     The other half of the same fix, and the one it would be easy to lose: trimming widens the gate
    ///     ONLY for JSON objects. A reference that is still not object-framed after the trim is not an
    ///     equipment-tag TagConfig at all — the pre-existing convention shared by all eleven inspectors —
    ///     so it keeps drawing nothing even though the mapper refuses it.
    /// </summary>
    /// <param name="reference">A padded, non-object reference.</param>
    [Theory]
    [InlineData("   just a string")]
    [InlineData("  [1,2,3]")]
    [InlineData(" \t\r\n 42")]
    [InlineData("  \"a\"")]
    [InlineData("  ")]
    public void A_non_object_reference_still_draws_nothing_after_trimming(string reference)
    {
        TwinCATTagDefinitionFactory.FromTagConfig(reference, RawPath, out _).ShouldBeFalse();
        TwinCATTagDefinitionFactory.Inspect(reference).ShouldBeEmpty();
    }
}