using Microsoft.Extensions.Logging.Abstractions;
using Opc.Ua;
using Shouldly;
using Xunit;
using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;

namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests;

/// <summary>
///     Phase 4c Task 1 — node-manager materialisation honours the array intent. Boot a real
///     <see cref="OtOpcUaSdkServer"/> through <see cref="OpcUaApplicationHost"/> (the same harness
///     <see cref="NodeManagerHistorizeTests"/> uses), drive
///     <see cref="OtOpcUaNodeManager.EnsureVariable"/> with / without the new <c>isArray</c> /
///     <c>arrayLength</c> params, and assert the created <see cref="BaseDataVariableState"/>'s
///     <c>ValueRank</c> + <c>ArrayDimensions</c>. Also proves the existing value-write path already
///     round-trips a CLR array with no change.
/// </summary>
public sealed class NodeManagerArrayTests : IDisposable
{
    private static CancellationToken Ct => TestContext.Current.CancellationToken;

    private readonly string _pkiRoot = Path.Combine(
        Path.GetTempPath(),
        $"otopcua-array-{Guid.NewGuid():N}");

    /// <summary>An array variable is created with ValueRank=OneDimension and a single-element
    /// ArrayDimensions carrying the requested length.</summary>
    [Fact]
    public async Task EnsureVariable_with_isArray_sets_one_dimension_rank_and_array_dimensions()
    {
        var (host, server) = await BootAsync();
        var nm = server.NodeManager!;

        nm.EnsureVariable("eq-1/arr", parentFolderNodeId: null, displayName: "arr", dataType: "Int32",
            writable: false, historianTagname: null, isArray: true, arrayLength: 8, realm: AddressSpaceRealm.Uns);

        var variable = nm.TryGetVariable("eq-1/arr");
        variable.ShouldNotBeNull();
        variable!.ValueRank.ShouldBe(ValueRanks.OneDimension);
        variable.ArrayDimensions.ShouldNotBeNull();
        variable.ArrayDimensions.ShouldBe(new uint[] { 8u });

        await host.DisposeAsync();
    }

    /// <summary>When arrayLength is null the created node must still be a 1-D array (ValueRank=OneDimension)
    /// with ArrayDimensions [0] — the "unfixed-length" contract.</summary>
    [Fact]
    public async Task EnsureVariable_with_null_arrayLength_sets_dimension_zero()
    {
        var (host, server) = await BootAsync();
        var nm = server.NodeManager!;

        nm.EnsureVariable("eq-1/arr-unfixed", parentFolderNodeId: null, displayName: "arr-unfixed", dataType: "Int32",
            writable: false, historianTagname: null, isArray: true, arrayLength: null, realm: AddressSpaceRealm.Uns);

        var variable = nm.TryGetVariable("eq-1/arr-unfixed");
        variable.ShouldNotBeNull();
        variable!.ValueRank.ShouldBe(ValueRanks.OneDimension);
        variable.ArrayDimensions.ShouldNotBeNull();
        variable.ArrayDimensions.ShouldBe(new uint[] { 0u });

        await host.DisposeAsync();
    }

    /// <summary>A default (scalar) EnsureVariable call keeps ValueRank=Scalar and leaves
    /// ArrayDimensions null/empty.</summary>
    [Fact]
    public async Task EnsureVariable_default_is_scalar_with_no_array_dimensions()
    {
        var (host, server) = await BootAsync();
        var nm = server.NodeManager!;

        nm.EnsureVariable("eq-1/scalar", parentFolderNodeId: null, displayName: "scalar", dataType: "Int32",
            writable: false, realm: AddressSpaceRealm.Uns);

        var variable = nm.TryGetVariable("eq-1/scalar");
        variable.ShouldNotBeNull();
        variable!.ValueRank.ShouldBe(ValueRanks.Scalar);
        variable.ArrayDimensions.ShouldBeNull();

        await host.DisposeAsync();
    }

    /// <summary>The existing WriteValue path round-trips a CLR array onto an array node with no change:
    /// after EnsureVariable(isArray:true), WriteValue(int[]) surfaces the array verbatim with Good status.</summary>
    [Fact]
    public async Task WriteValue_round_trips_a_clr_array_onto_an_array_node()
    {
        var (host, server) = await BootAsync();
        var nm = server.NodeManager!;

        nm.EnsureVariable("eq-1/arrwrite", parentFolderNodeId: null, displayName: "arrwrite", dataType: "Int32",
            writable: false, historianTagname: null, isArray: true, arrayLength: 3, realm: AddressSpaceRealm.Uns);

        var payload = new[] { 1, 2, 3 };
        nm.WriteValue("eq-1/arrwrite", payload, OpcUaStatus.Good, DateTime.UtcNow, realm: AddressSpaceRealm.Uns);

        var variable = nm.TryGetVariable("eq-1/arrwrite");
        variable.ShouldNotBeNull();
        variable!.Value.ShouldBe(payload);
        variable.StatusCode.ShouldBe((StatusCode)StatusCodes.Good);

        await host.DisposeAsync();
    }

    /// <summary>
    ///     Gitea #519, second hop — the node manager hands the caller's status code to the SDK
    ///     <b>verbatim</b>, sub-code included.
    ///     <para>It used to re-expand a 3-state enum here (<c>Bad =&gt; StatusCodes.Bad</c>), so every Bad
    ///     sub-code a driver produced landed on the wire as <c>0x80000000</c>. Boots a real SDK server and
    ///     reads the created <see cref="BaseDataVariableState"/> back, which is the value an OPC UA client
    ///     would receive.</para>
    ///     <para>Asserting two DIFFERENT Bad sub-codes is what makes this falsifiable: under the old
    ///     projection both collapsed to the same value, so a single-code assertion could pass on a
    ///     hard-coded constant.</para>
    /// </summary>
    [Fact]
    public async Task WriteValue_hands_the_status_sub_code_to_the_SDK_verbatim()
    {
        var (host, server) = await BootAsync();
        var nm = server.NodeManager!;

        nm.EnsureVariable("eq-1/subcode", parentFolderNodeId: null, displayName: "subcode", dataType: "Double",
            writable: false, historianTagname: null, realm: AddressSpaceRealm.Uns);

        nm.WriteValue("eq-1/subcode", null, OpcUaStatus.BadNoCommunication, DateTime.UtcNow,
            realm: AddressSpaceRealm.Uns);

        var variable = nm.TryGetVariable("eq-1/subcode");
        variable.ShouldNotBeNull();
        variable!.StatusCode.ShouldBe((StatusCode)StatusCodes.BadNoCommunication);
        variable.StatusCode.ShouldNotBe((StatusCode)StatusCodes.Bad,
            "the sub-code was collapsed to a generic Bad — this is exactly the #519 defect");

        // A different Bad sub-code must land differently.
        nm.WriteValue("eq-1/subcode", null, 0x80740000u /* BadTypeMismatch */, DateTime.UtcNow,
            realm: AddressSpaceRealm.Uns);
        nm.TryGetVariable("eq-1/subcode")!.StatusCode.ShouldBe((StatusCode)StatusCodes.BadTypeMismatch);

        // Uncertain and Good still round-trip.
        nm.WriteValue("eq-1/subcode", 1.0, OpcUaStatus.Good, DateTime.UtcNow, realm: AddressSpaceRealm.Uns);
        nm.TryGetVariable("eq-1/subcode")!.StatusCode.ShouldBe((StatusCode)StatusCodes.Good);

        await host.DisposeAsync();
    }

    private async Task<(OpcUaApplicationHost Host, OtOpcUaSdkServer Server)> BootAsync()
    {
        var applicationUri = $"urn:OtOpcUa.ArrayTest:{Guid.NewGuid():N}";
        var started = await OpcUaHostStart.StartAsync(
            port => new OpcUaApplicationHost(
                new OpcUaApplicationHostOptions
                {
                    ApplicationName = "OtOpcUa.ArrayTest",
                    ApplicationUri = applicationUri,
                    OpcUaPort = port,
                    PublicHostname = "localhost",
                    PkiStoreRoot = _pkiRoot,
                },
                NullLogger<OpcUaApplicationHost>.Instance),
            () => new OtOpcUaSdkServer(), Ct);
        var host = started.Host;
        var server = started.Server;
        return (host, server);
    }

    /// <summary>Cleans up the PKI root directory.</summary>
    public void Dispose()
    {
        if (Directory.Exists(_pkiRoot))
        {
            try { Directory.Delete(_pkiRoot, recursive: true); }
            catch { /* best-effort cleanup */ }
        }
    }
}