using System.Text.Json;
using Shouldly;
using Xunit;
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
using ZB.MOM.WW.OtOpcUa.Driver.S7.SymbolImport;

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

/// <summary>
///     PR-S7-D2 — UDT / STRUCT fan-out unit tests. Verifies the recursive flattening of
///     UDT-typed parent tags into scalar leaf member tags happens correctly at
///     <see cref="S7Driver.InitializeAsync"/> time, that the depth cap (4 levels) is
///     enforced, and that misordered / overlapping / unknown UDT references fail with
///     the expected error shape.
/// </summary>
[Trait("Category", "Unit")]
public sealed class S7UdtFanOutTests
{
    private static S7DriverOptions OptionsWith(IReadOnlyList<S7TagDefinition> tags, IReadOnlyList<S7UdtDefinition> udts)
        => new()
        {
            Host = "192.0.2.1", // RFC 5737 reserved — never reachable; we only exercise the parse + fan-out path.
            Timeout = TimeSpan.FromMilliseconds(50),
            Tags = tags,
            Udts = udts,
            Probe = new S7ProbeOptions { Enabled = false },
        };

    /// <summary>
    ///     Run InitializeAsync against an unreachable host so the parse / fan-out validation
    ///     happens before the TCP connect attempt fails. Returns the exception so tests can
    ///     assert on its shape; throws if the unexpected exception type bubbled up.
    /// </summary>
    private static async Task<Exception> InitAndCaptureFanOutErrorAsync(S7DriverOptions opts)
    {
        using var drv = new S7Driver(opts, "s7-udt-test");
        return await Should.ThrowAsync<Exception>(async () =>
            await drv.InitializeAsync("{}", TestContext.Current.CancellationToken));
    }

    /// <summary>
    ///     Direct-call helper that bypasses InitializeAsync's TCP connect: invokes the
    ///     fan-out helper directly so the test can inspect the produced leaf tag list
    ///     without spinning up a Plc.
    /// </summary>
    private static IReadOnlyList<S7TagDefinition> FanOut(
        S7TagDefinition parent, IReadOnlyList<S7UdtDefinition> udts)
    {
        var parsed = S7AddressParser.Parse(parent.Address);
        return S7UdtFanOut.Expand(parent, udts, parsed);
    }

    [Fact]
    public void Single_level_UDT_with_three_scalar_members_emits_three_tags()
    {
        var udt = new S7UdtDefinition("Sensor", new[]
        {
            new S7UdtMember("Pressure", 0, S7DataType.Float32),
            new S7UdtMember("Status", 4, S7DataType.Int16),
            new S7UdtMember("Enabled", 6, S7DataType.Bool),
        }, SizeBytes: 8);

        var parent = new S7TagDefinition("MySensor", "DB1.DBX0.0", S7DataType.Byte, UdtName: "Sensor");

        var leaves = FanOut(parent, [udt]);

        leaves.Count.ShouldBe(3);
        leaves[0].Name.ShouldBe("MySensor.Pressure");
        leaves[0].Address.ShouldBe("DB1.DBD0");
        leaves[0].DataType.ShouldBe(S7DataType.Float32);
        leaves[1].Name.ShouldBe("MySensor.Status");
        leaves[1].Address.ShouldBe("DB1.DBW4");
        leaves[2].Name.ShouldBe("MySensor.Enabled");
        leaves[2].Address.ShouldBe("DB1.DBX6.0");
    }

    [Fact]
    public void Nested_UDT_recursively_flattens_with_dot_separated_paths()
    {
        var inner = new S7UdtDefinition("Telemetry", new[]
        {
            new S7UdtMember("Pressure", 0, S7DataType.Float32),
            new S7UdtMember("Temperature", 4, S7DataType.Float32),
        }, SizeBytes: 8);

        var outer = new S7UdtDefinition("Pump", new[]
        {
            new S7UdtMember("Telemetry", 0, S7DataType.Byte, UdtName: "Telemetry"),
            new S7UdtMember("Speed", 8, S7DataType.Int16),
        }, SizeBytes: 10);

        var parent = new S7TagDefinition("Pump1", "DB2.DBX0.0", S7DataType.Byte, UdtName: "Pump");

        var leaves = FanOut(parent, [outer, inner]);

        leaves.Count.ShouldBe(3);
        leaves[0].Name.ShouldBe("Pump1.Telemetry.Pressure");
        leaves[0].Address.ShouldBe("DB2.DBD0");
        leaves[1].Name.ShouldBe("Pump1.Telemetry.Temperature");
        leaves[1].Address.ShouldBe("DB2.DBD4");
        leaves[2].Name.ShouldBe("Pump1.Speed");
        leaves[2].Address.ShouldBe("DB2.DBW8");
    }

    [Fact]
    public void Four_level_nesting_succeeds_at_the_cap()
    {
        // L4 is the deepest level the cap allows.
        var l4 = new S7UdtDefinition("L4", [new S7UdtMember("Leaf", 0, S7DataType.Int16)], SizeBytes: 2);
        var l3 = new S7UdtDefinition("L3", [new S7UdtMember("X", 0, S7DataType.Byte, UdtName: "L4")], SizeBytes: 2);
        var l2 = new S7UdtDefinition("L2", [new S7UdtMember("X", 0, S7DataType.Byte, UdtName: "L3")], SizeBytes: 2);
        var l1 = new S7UdtDefinition("L1", [new S7UdtMember("X", 0, S7DataType.Byte, UdtName: "L2")], SizeBytes: 2);

        var parent = new S7TagDefinition("Root", "DB1.DBX0.0", S7DataType.Byte, UdtName: "L1");

        var leaves = FanOut(parent, [l1, l2, l3, l4]);

        leaves.Count.ShouldBe(1);
        leaves[0].Name.ShouldBe("Root.X.X.X.Leaf");
    }

    [Fact]
    public void Five_level_nesting_throws_with_clear_error()
    {
        // Add a fifth level — exceeds the depth cap.
        var l5 = new S7UdtDefinition("L5", [new S7UdtMember("Leaf", 0, S7DataType.Int16)], SizeBytes: 2);
        var l4 = new S7UdtDefinition("L4", [new S7UdtMember("X", 0, S7DataType.Byte, UdtName: "L5")], SizeBytes: 2);
        var l3 = new S7UdtDefinition("L3", [new S7UdtMember("X", 0, S7DataType.Byte, UdtName: "L4")], SizeBytes: 2);
        var l2 = new S7UdtDefinition("L2", [new S7UdtMember("X", 0, S7DataType.Byte, UdtName: "L3")], SizeBytes: 2);
        var l1 = new S7UdtDefinition("L1", [new S7UdtMember("X", 0, S7DataType.Byte, UdtName: "L2")], SizeBytes: 2);

        var parent = new S7TagDefinition("Root", "DB1.DBX0.0", S7DataType.Byte, UdtName: "L1");

        var ex = Should.Throw<InvalidOperationException>(() => FanOut(parent, [l1, l2, l3, l4, l5]));
        ex.Message.ShouldContain("nesting depth", Case.Insensitive);
        ex.Message.ShouldContain("4");
    }

    [Fact]
    public void Reference_to_unknown_UDT_throws_with_clear_error()
    {
        var parent = new S7TagDefinition("MissingUdtTag", "DB1.DBX0.0", S7DataType.Byte, UdtName: "DoesNotExist");

        var ex = Should.Throw<InvalidOperationException>(() => FanOut(parent, []));
        ex.Message.ShouldContain("DoesNotExist");
        ex.Message.ShouldContain("MissingUdtTag");
        ex.Message.ShouldContain("not declared", Case.Insensitive);
    }

    [Fact]
    public void Misordered_member_offsets_throw_at_fan_out()
    {
        var udt = new S7UdtDefinition("Bad", new[]
        {
            new S7UdtMember("First", 4, S7DataType.Int16),
            new S7UdtMember("Second", 0, S7DataType.Int16), // earlier byte than First.
        }, SizeBytes: 8);

        var parent = new S7TagDefinition("T", "DB1.DBX0.0", S7DataType.Byte, UdtName: "Bad");

        var ex = Should.Throw<InvalidOperationException>(() => FanOut(parent, [udt]));
        ex.Message.ShouldContain("misordered", Case.Insensitive);
    }

    [Fact]
    public void Overlapping_member_offsets_throw_at_fan_out()
    {
        // Float32 at offset 0 occupies bytes 0..3; Int16 at offset 2 overlaps.
        var udt = new S7UdtDefinition("Overlap", new[]
        {
            new S7UdtMember("Wide", 0, S7DataType.Float32),
            new S7UdtMember("Narrow", 2, S7DataType.Int16),
        }, SizeBytes: 8);

        var parent = new S7TagDefinition("T", "DB1.DBX0.0", S7DataType.Byte, UdtName: "Overlap");

        var ex = Should.Throw<InvalidOperationException>(() => FanOut(parent, [udt]));
        ex.Message.ShouldContain("overlap", Case.Insensitive);
    }

    [Fact]
    public void Array_member_with_three_elements_emits_three_indexed_sub_tags()
    {
        var udt = new S7UdtDefinition("Bank", new[]
        {
            new S7UdtMember("Sensors", 0, S7DataType.Float32, ArrayDim: 3),
            new S7UdtMember("Count", 12, S7DataType.Int16),
        }, SizeBytes: 14);

        var parent = new S7TagDefinition("Bank1", "DB3.DBX0.0", S7DataType.Byte, UdtName: "Bank");

        var leaves = FanOut(parent, [udt]);

        leaves.Count.ShouldBe(4);
        leaves[0].Name.ShouldBe("Bank1.Sensors[0]");
        leaves[0].Address.ShouldBe("DB3.DBD0");
        leaves[1].Name.ShouldBe("Bank1.Sensors[1]");
        leaves[1].Address.ShouldBe("DB3.DBD4");
        leaves[2].Name.ShouldBe("Bank1.Sensors[2]");
        leaves[2].Address.ShouldBe("DB3.DBD8");
        leaves[3].Name.ShouldBe("Bank1.Count");
        leaves[3].Address.ShouldBe("DB3.DBW12");
    }

    [Fact]
    public void DTO_round_trip_preserves_UdtName_and_Udts_collection()
    {
        var dto = new S7DriverFactoryExtensions.S7DriverConfigDto
        {
            Host = "10.0.0.5",
            Tags =
            [
                new S7DriverFactoryExtensions.S7TagDto
                {
                    Name = "Pump1",
                    Address = "DB1.DBX0.0",
                    DataType = "Byte",
                    UdtName = "Pump",
                }
            ],
            Udts =
            [
                new S7DriverFactoryExtensions.S7UdtDto
                {
                    Name = "Pump",
                    SizeBytes = 8,
                    Members =
                    [
                        new S7DriverFactoryExtensions.S7UdtMemberDto
                        {
                            Name = "Pressure", Offset = 0, DataType = "Float32"
                        },
                        new S7DriverFactoryExtensions.S7UdtMemberDto
                        {
                            Name = "Status", Offset = 4, DataType = "Int16"
                        },
                    ],
                }
            ],
        };

        var json = JsonSerializer.Serialize(dto);
        var back = JsonSerializer.Deserialize<S7DriverFactoryExtensions.S7DriverConfigDto>(json)!;

        back.Tags.ShouldNotBeNull();
        back.Tags!.Count.ShouldBe(1);
        back.Tags[0].UdtName.ShouldBe("Pump");

        back.Udts.ShouldNotBeNull();
        back.Udts!.Count.ShouldBe(1);
        back.Udts[0].Name.ShouldBe("Pump");
        back.Udts[0].SizeBytes.ShouldBe(8);
        back.Udts[0].Members!.Count.ShouldBe(2);
        back.Udts[0].Members![0].Name.ShouldBe("Pressure");
        back.Udts[0].Members![0].DataType.ShouldBe("Float32");
    }

    [Fact]
    public void Tag_with_both_UdtName_and_DataType_uses_UdtName()
    {
        // When both are set, UdtName wins — the primitive DataType is ignored because the
        // parent tag is replaced wholesale by its scalar leaves at fan-out time.
        var udt = new S7UdtDefinition("Tiny", [new S7UdtMember("V", 0, S7DataType.Int16)], SizeBytes: 2);

        // Parent declares DataType=Float32 and UdtName=Tiny. The leaf comes out as Int16 (per UDT),
        // not Float32, proving UdtName trumps the primitive DataType.
        var parent = new S7TagDefinition("Either", "DB1.DBX0.0", S7DataType.Float32, UdtName: "Tiny");

        var leaves = FanOut(parent, [udt]);

        leaves.Count.ShouldBe(1);
        leaves[0].DataType.ShouldBe(S7DataType.Int16);
        leaves[0].Name.ShouldBe("Either.V");
    }

    [Fact]
    public async Task Initialize_with_UDT_tag_replaces_parent_with_leaves_in_address_space()
    {
        // End-to-end driver path: fan-out should populate the discovery folder with the
        // leaves, NOT the parent. Initialize will fail at TCP connect (unreachable host),
        // but only AFTER the parse + fan-out has populated the tag map.
        var udt = new S7UdtDefinition("Sensor", new[]
        {
            new S7UdtMember("Pressure", 0, S7DataType.Float32),
            new S7UdtMember("Status", 4, S7DataType.Int16),
        }, SizeBytes: 6);

        var opts = OptionsWith(
            tags: [new S7TagDefinition("MySensor", "DB1.DBX0.0", S7DataType.Byte, UdtName: "Sensor")],
            udts: [udt]);

        var ex = await InitAndCaptureFanOutErrorAsync(opts);
        // The fan-out itself didn't throw (UDT was found, layout valid) — only the TCP connect
        // failed with a socket / timeout exception. That's the expected shape.
        ex.ShouldNotBeOfType<InvalidOperationException>();
    }

    [Fact]
    public async Task Initialize_with_UDT_referencing_unknown_layout_fails_at_fan_out()
    {
        var opts = OptionsWith(
            tags: [new S7TagDefinition("MissingUdtTag", "DB1.DBX0.0", S7DataType.Byte, UdtName: "DoesNotExist")],
            udts: []);

        var ex = await InitAndCaptureFanOutErrorAsync(opts);
        ex.ShouldBeOfType<InvalidOperationException>();
        ex.Message.ShouldContain("DoesNotExist");
    }

    [Fact]
    public async Task Initialize_rejects_UDT_tag_with_ElementCount_greater_than_one()
    {
        var udt = new S7UdtDefinition("Tiny", [new S7UdtMember("V", 0, S7DataType.Int16)], SizeBytes: 2);
        var opts = OptionsWith(
            tags: [new S7TagDefinition("BadArrayUdt", "DB1.DBX0.0", S7DataType.Byte,
                ElementCount: 5, UdtName: "Tiny")],
            udts: [udt]);

        var ex = await InitAndCaptureFanOutErrorAsync(opts);
        ex.ShouldBeOfType<FormatException>();
        ex.Message.ShouldContain("array-of-UDT", Case.Insensitive);
    }

    [Fact]
    public void Array_of_nested_UDT_strides_member_addresses_by_inner_size()
    {
        // Inner UDT is 4 bytes wide (one Float32). An array of 3 of these strides 4 bytes
        // per element. Outer UDT places the array at offset 0, so the leaves should be at
        // bytes 0, 4, 8.
        var inner = new S7UdtDefinition("Reading", [new S7UdtMember("Value", 0, S7DataType.Float32)], SizeBytes: 4);
        var outer = new S7UdtDefinition("Channel", new[]
        {
            new S7UdtMember("Readings", 0, S7DataType.Byte, ArrayDim: 3, UdtName: "Reading"),
        }, SizeBytes: 12);

        var parent = new S7TagDefinition("Ch1", "DB1.DBX0.0", S7DataType.Byte, UdtName: "Channel");

        var leaves = FanOut(parent, [outer, inner]);

        leaves.Count.ShouldBe(3);
        leaves[0].Name.ShouldBe("Ch1.Readings[0].Value");
        leaves[0].Address.ShouldBe("DB1.DBD0");
        leaves[1].Name.ShouldBe("Ch1.Readings[1].Value");
        leaves[1].Address.ShouldBe("DB1.DBD4");
        leaves[2].Name.ShouldBe("Ch1.Readings[2].Value");
        leaves[2].Address.ShouldBe("DB1.DBD8");
    }

    [Fact]
    public void Members_extending_past_SizeBytes_throw()
    {
        // A 4-byte Float32 at offset 6 ends at 10, but SizeBytes claims 8.
        var udt = new S7UdtDefinition("Cramped", new[]
        {
            new S7UdtMember("X", 6, S7DataType.Float32),
        }, SizeBytes: 8);

        var parent = new S7TagDefinition("T", "DB1.DBX0.0", S7DataType.Byte, UdtName: "Cramped");

        var ex = Should.Throw<InvalidOperationException>(() => FanOut(parent, [udt]));
        ex.Message.ShouldContain("SizeBytes", Case.Insensitive);
    }
}