using System.Collections.Concurrent;
using Shouldly;
using Xunit;
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
using ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Wire;

namespace ZB.MOM.WW.OtOpcUa.Driver.FOCAS.IntegrationTests.Series;

/// <summary>
///     End-to-end coverage for the driver capabilities that aren't part of
///     the fixed-tree path: user-authored <c>PARAM:</c> / <c>MACRO:</c> / PMC
///     reads, <c>DiscoverAsync</c> emission, <c>SubscribeAsync</c> +
///     <c>OnDataChange</c>, <c>IAlarmSource</c> raise/clear, and
///     <c>IHostConnectivityProbe</c> transitions. All via the managed
///     <see cref="WireFocasClient"/> against the running focas-mock.
/// </summary>
[Collection(FocasSimCollection.Name)]
public sealed class WireBackendCoverageTests
{
    private readonly FocasSimFixture _fx;

    public WireBackendCoverageTests(FocasSimFixture fx) => _fx = fx;

    private const string DeviceHost = "focas://127.0.0.1:8193";

    [Fact]
    public async Task User_tag_reads_route_via_wire_backend()
    {
        if (_fx.SkipReason is not null) Assert.Skip(_fx.SkipReason);
        var ct = TestContext.Current.CancellationToken;

        await _fx.LoadProfileAsync("FWLIB64", ct);
        await _fx.PatchStateAsync(new
        {
            parameters = new Dictionary<string, object>
            {
                ["6711"] = new { type = "long", value = 1234, @decimal = 0 },
            },
            macros = new Dictionary<string, object>
            {
                ["500"] = new { value = 42000, @decimal = 3 },
            },
            pmc = new { R = new Dictionary<string, object>
            {
                ["100"] = new { type = "byte", value = 7 },
            }},
        }, ct);

        var drv = new FocasDriver(new FocasDriverOptions
        {
            Devices = [new FocasDeviceOptions(DeviceHost)],
            Tags =
            [
                new FocasTagDefinition("Param6711", DeviceHost, "PARAM:6711", FocasDataType.Int32, Writable: false),
                new FocasTagDefinition("Macro500",  DeviceHost, "MACRO:500",  FocasDataType.Float64, Writable: false),
                new FocasTagDefinition("R100",      DeviceHost, "R100",       FocasDataType.Byte, Writable: false),
            ],
            Probe = new FocasProbeOptions { Enabled = false },
        }, driverInstanceId: "wire-usertags", clientFactory: new WireFocasClientFactory());

        await using (drv)
        {
            await drv.InitializeAsync("{}", ct);
            var snaps = await drv.ReadAsync(["Param6711", "Macro500", "R100"], ct);
            snaps.ShouldAllBe(s => s.StatusCode == FocasStatusMapper.Good);
            Convert.ToInt32(snaps[0].Value).ShouldBe(1234);
            Convert.ToDouble(snaps[1].Value).ShouldBe(42.0, tolerance: 0.001);
            Convert.ToInt32(snaps[2].Value).ShouldBe(7);
        }
    }

    [Fact]
    public async Task Discover_emits_device_folder_and_tag_variables()
    {
        if (_fx.SkipReason is not null) Assert.Skip(_fx.SkipReason);
        var ct = TestContext.Current.CancellationToken;

        await _fx.LoadProfileAsync("FWLIB64", ct);

        var drv = new FocasDriver(new FocasDriverOptions
        {
            Devices = [new FocasDeviceOptions(DeviceHost, DeviceName: "Lathe-1")],
            Tags =
            [
                new FocasTagDefinition("Run",   DeviceHost, "R100", FocasDataType.Byte, Writable: false),
                new FocasTagDefinition("Speed", DeviceHost, "MACRO:500", FocasDataType.Float64, Writable: false),
            ],
            Probe = new FocasProbeOptions { Enabled = false },
        }, driverInstanceId: "wire-discover", clientFactory: new WireFocasClientFactory());

        await using (drv)
        {
            await drv.InitializeAsync("{}", ct);

            var builder = new RecordingBuilder();
            await drv.DiscoverAsync(builder, ct);

            builder.Folders.ShouldContain(f => f.BrowseName == "FOCAS");
            builder.Folders.ShouldContain(f => f.BrowseName == DeviceHost && f.DisplayName == "Lathe-1");
            builder.Variables.ShouldContain(v => v.BrowseName == "Run");
            builder.Variables.ShouldContain(v => v.BrowseName == "Speed");
        }
    }

    [Fact]
    public async Task Subscribe_fires_OnDataChange_via_wire_backend()
    {
        if (_fx.SkipReason is not null) Assert.Skip(_fx.SkipReason);
        var ct = TestContext.Current.CancellationToken;

        await _fx.LoadProfileAsync("FWLIB64", ct);
        await _fx.PatchStateAsync(new
        {
            pmc = new { R = new Dictionary<string, object>
            {
                ["100"] = new { type = "byte", value = 1 },
            }},
        }, ct);

        var drv = new FocasDriver(new FocasDriverOptions
        {
            Devices = [new FocasDeviceOptions(DeviceHost)],
            Tags = [new FocasTagDefinition("Run", DeviceHost, "R100", FocasDataType.Byte, Writable: false)],
            Probe = new FocasProbeOptions { Enabled = false },
        }, driverInstanceId: "wire-subscribe", clientFactory: new WireFocasClientFactory());

        await using (drv)
        {
            await drv.InitializeAsync("{}", ct);
            var events = new ConcurrentQueue<DataChangeEventArgs>();
            drv.OnDataChange += (_, e) => events.Enqueue(e);

            var handle = await drv.SubscribeAsync(["Run"], TimeSpan.FromMilliseconds(150), ct);
            await WaitFor(() => events.Count >= 1, TimeSpan.FromSeconds(3));
            Convert.ToInt32(events.First().Snapshot.Value).ShouldBe(1);

            // Flip the PMC byte — next poll tick should emit a fresh OnDataChange.
            var before = events.Count;
            await _fx.PatchStateAsync(new
            {
                pmc = new { R = new Dictionary<string, object>
                {
                    ["100"] = new { type = "byte", value = 99 },
                }},
            }, ct);
            await WaitFor(() => events.Any(e => Convert.ToInt32(e.Snapshot.Value) == 99),
                          TimeSpan.FromSeconds(3));

            await drv.UnsubscribeAsync(handle, ct);
            events.Count.ShouldBeGreaterThan(before);
        }
    }

    [Fact]
    public async Task Alarm_raise_then_clear_emits_both_events_via_wire_backend()
    {
        if (_fx.SkipReason is not null) Assert.Skip(_fx.SkipReason);
        var ct = TestContext.Current.CancellationToken;

        await _fx.LoadProfileAsync("FWLIB64", ct);
        // Start with no active alarms.
        await _fx.PatchStateAsync(new { alarms = Array.Empty<object>() }, ct);

        var drv = new FocasDriver(new FocasDriverOptions
        {
            Devices = [new FocasDeviceOptions(DeviceHost)],
            Tags = [],
            Probe = new FocasProbeOptions { Enabled = false },
            AlarmProjection = new FocasAlarmProjectionOptions
            {
                Enabled = true,
                PollInterval = TimeSpan.FromMilliseconds(200),
            },
        }, driverInstanceId: "wire-alarms", clientFactory: new WireFocasClientFactory());

        await using (drv)
        {
            await drv.InitializeAsync("{}", ct);
            var events = new List<AlarmEventArgs>();
            drv.OnAlarmEvent += (_, e) => { lock (events) events.Add(e); };

            var sub = await drv.SubscribeAlarmsAsync([], ct);

            // Raise one alarm.
            await _fx.PatchStateAsync(new
            {
                alarms = new[]
                {
                    new { alm_no = 500, type = 2, axis = 1, msg = "TEST OVERTRAVEL" },
                },
            }, ct);
            await WaitFor(() => events.Any(e => e.Message.Contains("OVERTRAVEL")), TimeSpan.FromSeconds(5));

            // Clear.
            await _fx.PatchStateAsync(new { alarms = Array.Empty<object>() }, ct);
            await WaitFor(() => events.Any(e => e.Message.Contains("cleared")), TimeSpan.FromSeconds(5));

            await drv.UnsubscribeAlarmsAsync(sub, ct);

            events.ShouldContain(e => e.AlarmType == "Overtravel" && e.Severity == AlarmSeverity.Critical);
            events.ShouldContain(e => e.Message.Contains("cleared"));
            events[0].SourceNodeId.ShouldBe(DeviceHost);
        }
    }

    [Fact]
    public async Task Probe_transitions_to_Running_against_live_mock()
    {
        if (_fx.SkipReason is not null) Assert.Skip(_fx.SkipReason);
        var ct = TestContext.Current.CancellationToken;

        var transitions = new ConcurrentQueue<HostStatusChangedEventArgs>();
        var drv = new FocasDriver(new FocasDriverOptions
        {
            Devices = [new FocasDeviceOptions(DeviceHost)],
            Probe = new FocasProbeOptions
            {
                Enabled = true,
                Interval = TimeSpan.FromMilliseconds(150),
                Timeout = TimeSpan.FromSeconds(1),
            },
        }, driverInstanceId: "wire-probe", clientFactory: new WireFocasClientFactory());
        drv.OnHostStatusChanged += (_, e) => transitions.Enqueue(e);

        await using (drv)
        {
            await drv.InitializeAsync("{}", ct);
            await WaitFor(() => transitions.Any(t => t.NewState == HostState.Running), TimeSpan.FromSeconds(5));
            drv.GetHostStatuses().Single().State.ShouldBe(HostState.Running);
        }
    }

    private static async Task WaitFor(Func<bool> pred, TimeSpan timeout)
    {
        var deadline = DateTime.UtcNow + timeout;
        while (DateTime.UtcNow < deadline)
        {
            if (pred()) return;
            await Task.Delay(50);
        }
    }

    private sealed class RecordingBuilder : IAddressSpaceBuilder
    {
        public List<(string BrowseName, string DisplayName)> Folders { get; } = new();
        public List<(string BrowseName, DriverAttributeInfo Info)> Variables { get; } = new();

        public IAddressSpaceBuilder Folder(string browseName, string displayName)
        { Folders.Add((browseName, displayName)); return this; }

        public IVariableHandle Variable(string browseName, string displayName, DriverAttributeInfo info)
        { Variables.Add((browseName, info)); return new Handle(info.FullName); }

        public void AddProperty(string _, DriverDataType __, object? ___) { }

        private sealed class Handle(string fullRef) : IVariableHandle
        {
            public string FullReference => fullRef;
            public IAlarmConditionSink MarkAsAlarmCondition(AlarmConditionInfo info) => new NullSink();
        }
        private sealed class NullSink : IAlarmConditionSink { public void OnTransition(AlarmEventArgs args) { } }
    }
}