/* ========================================================================
 * Copyright (c) 2005-2026 The OPC Foundation, Inc. All rights reserved.
 *
 * OPC Foundation MIT License 1.00
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * The complete license agreement can be found here:
 * http://opcfoundation.org/License/MIT/1.00/
 * ======================================================================*/

using System;
using System.Threading;
using System.Threading.Tasks;
using Moq;
using NUnit.Framework;
using Opc.Ua.PubSub.Adapter.Publisher;
using Opc.Ua.PubSub.Adapter.Session;
using Opc.Ua.PubSub.DataSets;
using Opc.Ua.PubSub.Encoding;

namespace Opc.Ua.PubSub.Adapter.Tests
{
    /// <summary>
    /// Unit tests for <see cref="ServerPublishedDataSetSource"/>: building
    /// read requests from published variables, mapping values to DataSet fields,
    /// fail-soft gap handling and metadata delegation.
    /// </summary>
    [TestFixture]
    public sealed class ServerPublishedDataSetSourceTests
    {
        private sealed class RecordingReadStrategy : IReadStrategy
        {
            private readonly ArrayOf<DataValue> m_values;

            public RecordingReadStrategy(ArrayOf<DataValue> values)
            {
                m_values = values;
            }

            public ArrayOf<ReadValueId> LastRead { get; private set; } = ArrayOf<ReadValueId>.Null;

            public ValueTask<ArrayOf<DataValue>> ReadAsync(
                ArrayOf<ReadValueId> nodesToRead,
                CancellationToken cancellationToken = default)
            {
                LastRead = nodesToRead;
                return new ValueTask<ArrayOf<DataValue>>(m_values);
            }
        }

        private static IDataSetMetaDataBuilder MetaDataBuilder()
        {
            var mock = new Mock<IDataSetMetaDataBuilder>();
            mock.Setup(b => b.BuildMetaData()).Returns(new DataSetMetaDataType { Name = "Meta" });
            mock.Setup(b => b.ResolveAsync(It.IsAny<CancellationToken>()))
                .Returns(new ValueTask<DataSetMetaDataType>(new DataSetMetaDataType()));
            return mock.Object;
        }

        private static DataSetMetaDataType MetaWithFields(params string[] names)
        {
            var fields = new FieldMetaData[names.Length];
            for (int i = 0; i < names.Length; i++)
            {
                fields[i] = new FieldMetaData { Name = names[i] };
            }
            return new DataSetMetaDataType { Fields = fields.ToArrayOf() };
        }

        [Test]
        public void ConstructorNullConfigurationThrows()
        {
            var strategy = new RecordingReadStrategy([]);

            Assert.That(
                () => new ServerPublishedDataSetSource(
                    null!, strategy, MetaDataBuilder(), AdapterTestHelpers.Telemetry()),
                Throws.ArgumentNullException.With.Property("ParamName").EqualTo("configuration"));
        }

        [Test]
        public void ConstructorNullStrategyThrows()
        {
            Assert.That(
                () => new ServerPublishedDataSetSource(
                    new PublishedDataSetDataType(), null!, MetaDataBuilder(),
                    AdapterTestHelpers.Telemetry()),
                Throws.ArgumentNullException.With.Property("ParamName").EqualTo("strategy"));
        }

        [Test]
        public void ConstructorNullMetaDataBuilderThrows()
        {
            var strategy = new RecordingReadStrategy([]);

            Assert.That(
                () => new ServerPublishedDataSetSource(
                    new PublishedDataSetDataType(), strategy, null!,
                    AdapterTestHelpers.Telemetry()),
                Throws.ArgumentNullException.With.Property("ParamName").EqualTo("metaDataBuilder"));
        }

        [Test]
        public void BuildMetaDataDelegatesToBuilder()
        {
            var builder = new Mock<IDataSetMetaDataBuilder>();
            builder.Setup(b => b.BuildMetaData())
                .Returns(new DataSetMetaDataType { Name = "Delegated" });
            var source = new ServerPublishedDataSetSource(
                new PublishedDataSetDataType(),
                new RecordingReadStrategy([]),
                builder.Object,
                AdapterTestHelpers.Telemetry());

            DataSetMetaDataType metaData = source.BuildMetaData();

            Assert.That(metaData.Name, Is.EqualTo("Delegated"));
            builder.Verify(b => b.BuildMetaData(), Times.Once);
        }

        [Test]
        public async Task SampleBuildsReadValueIdsFromPublishedVariables()
        {
            PublishedDataSetDataType config = AdapterTestHelpers.PublishedDataSet(
                "PDS",
                AdapterTestHelpers.Variable.Value(new NodeId(11u)),
                AdapterTestHelpers.Variable.Value(new NodeId(22u)));
            var strategy = new RecordingReadStrategy(new[]
            {
                new DataValue(new Variant(1)),
                new DataValue(new Variant(2))
            }.ToArrayOf());
            var source = new ServerPublishedDataSetSource(
                config, strategy, MetaDataBuilder(), AdapterTestHelpers.Telemetry());

            await source.SampleAsync(MetaWithFields("A", "B")).ConfigureAwait(false);

            Assert.That(strategy.LastRead.Count, Is.EqualTo(2));
            Assert.That(strategy.LastRead[0].NodeId, Is.EqualTo(new NodeId(11u)));
            Assert.That(strategy.LastRead[0].AttributeId, Is.EqualTo(Attributes.Value));
            Assert.That(strategy.LastRead[1].NodeId, Is.EqualTo(new NodeId(22u)));
        }

        [Test]
        public async Task SampleMapsDataValuesToDataSetFields()
        {
            var sourceTimestamp = new DateTime(2024, 1, 2, 3, 4, 5, DateTimeKind.Utc);
            PublishedDataSetDataType config = AdapterTestHelpers.PublishedDataSet(
                "PDS", AdapterTestHelpers.Variable.Value(new NodeId(11u)));
            DataValue[] readValues =
            [
                new DataValue(
                    new Variant(99), StatusCodes.Good, DateTimeUtc.From(sourceTimestamp))
            ];
            var strategy = new RecordingReadStrategy(readValues.ToArrayOf());
            var source = new ServerPublishedDataSetSource(
                config, strategy, MetaDataBuilder(), AdapterTestHelpers.Telemetry());

            PublishedDataSetSnapshot snapshot = await source.SampleAsync(MetaWithFields("Value1")).ConfigureAwait(false);

            DataSetField[] fields = (DataSetField[]?)snapshot.Fields ?? [];
            Assert.That(fields, Has.Length.EqualTo(1));
            Assert.That(fields[0].Name, Is.EqualTo("Value1"));
            Assert.That(fields[0].Value, Is.EqualTo(new Variant(99)));
            Assert.That(fields[0].StatusCode, Is.EqualTo(StatusCodes.Good));
        }

        [Test]
        public async Task SampleFillsGapsWithBadNoData()
        {
            PublishedDataSetDataType config = AdapterTestHelpers.PublishedDataSet(
                "PDS",
                AdapterTestHelpers.Variable.Value(new NodeId(11u)),
                AdapterTestHelpers.Variable.Value(new NodeId(22u)));
            var strategy = new RecordingReadStrategy(new[]
            {
                new DataValue(new Variant(1))
            }.ToArrayOf());
            var source = new ServerPublishedDataSetSource(
                config, strategy, MetaDataBuilder(), AdapterTestHelpers.Telemetry());

            PublishedDataSetSnapshot snapshot = await source.SampleAsync(MetaWithFields("A", "B")).ConfigureAwait(false);

            DataSetField[] fields = (DataSetField[]?)snapshot.Fields ?? [];
            Assert.That(fields, Has.Length.EqualTo(2));
            Assert.That(fields[1].StatusCode, Is.EqualTo(StatusCodes.BadNoData));
        }

        [Test]
        public async Task SampleDelegatesMetaDataResolutionToBuilderEachCycle()
        {
            PublishedDataSetDataType config = AdapterTestHelpers.PublishedDataSet(
                "PDS", AdapterTestHelpers.Variable.Value(new NodeId(11u)));
            var builder = new Mock<IDataSetMetaDataBuilder>();
            builder.Setup(b => b.ResolveAsync(It.IsAny<CancellationToken>()))
                .Returns(new ValueTask<DataSetMetaDataType>(new DataSetMetaDataType()));
            var strategy = new RecordingReadStrategy(new[]
            {
                new DataValue(new Variant(1))
            }.ToArrayOf());
            var source = new ServerPublishedDataSetSource(
                config, strategy, builder.Object, AdapterTestHelpers.Telemetry());

            await source.SampleAsync(MetaWithFields("A")).ConfigureAwait(false);
            await source.SampleAsync(MetaWithFields("A")).ConfigureAwait(false);

            // The source delegates resolution to the builder every cycle; the
            // builder owns caching/retry (see DataSetMetaDataBuilderTests) so a
            // recovered server read re-resolves and re-emits metadata.
            builder.Verify(
                b => b.ResolveAsync(It.IsAny<CancellationToken>()), Times.Exactly(2));
        }

        /// <summary>
        /// A sampling operation admitted before retirement cannot complete with withdrawn values afterward.
        /// </summary>
        [Test]
        [Category("SecurityRegression")]
        public async Task SecurityF40RetiredSourceRejectsInFlightSnapshotAndMetadataNotifications()
        {
            PublishedDataSetDataType configuration = AdapterTestHelpers.PublishedDataSet(
                "Withdrawn", AdapterTestHelpers.Variable.Value(new NodeId(601u)));
            var builder = new Mock<IDataSetMetaDataBuilder>();
            builder.Setup(b => b.ResolveAsync(It.IsAny<CancellationToken>()))
                .Returns(new ValueTask<DataSetMetaDataType>(new DataSetMetaDataType()));
            var readStarted = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
            var releaseRead = new TaskCompletionSource<ArrayOf<DataValue>>(
                TaskCreationOptions.RunContinuationsAsynchronously);
            var strategy = new Mock<IReadStrategy>();
            strategy.Setup(s => s.ReadAsync(
                    It.IsAny<ArrayOf<ReadValueId>>(), It.IsAny<CancellationToken>()))
                .Returns(() =>
                {
                    readStarted.TrySetResult(true);
                    return new ValueTask<ArrayOf<DataValue>>(releaseRead.Task);
                });
            var source = new ServerPublishedDataSetSource(
                configuration, strategy.Object, builder.Object, AdapterTestHelpers.Telemetry());
            int metadataNotifications = 0;
            source.MetaDataChanged += (_, _) => metadataNotifications++;
            Task<PublishedDataSetSnapshot> sample = source.SampleAsync(MetaWithFields("Withdrawn")).AsTask();
            await readStarted.Task.ConfigureAwait(false);

            source.Retire();
            builder.Raise(b => b.MetaDataChanged += null, EventArgs.Empty);
            releaseRead.TrySetResult([new DataValue(999)]);

            Assert.That(
                () => sample,
                Throws.TypeOf<ObjectDisposedException>());
            Assert.That(() => source.BuildMetaData(), Throws.TypeOf<ObjectDisposedException>());
            Assert.That(metadataNotifications, Is.Zero);
        }

        /// <summary>
        /// Metadata shutdown drains an admitted read before disposing its gate and cannot relay late model changes.
        /// </summary>
        [Test]
        [Category("SecurityRegression")]
        public async Task SecurityF40MetadataRetirementDrainsInFlightRead()
        {
            var readStarted = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
            var releaseRead = new TaskCompletionSource<ArrayOf<DataValue>>(
                TaskCreationOptions.RunContinuationsAsynchronously);
            Mock<IServerSession> session = AdapterTestHelpers.ConnectedSession();
            session.Setup(s => s.ReadAsync(
                    It.IsAny<ArrayOf<ReadValueId>>(), It.IsAny<CancellationToken>()))
                .Returns(() =>
                {
                    readStarted.TrySetResult(true);
                    return new ValueTask<ArrayOf<DataValue>>(releaseRead.Task);
                });
            await using IServerSession sessionScope = session.Object;
            PublishedDataSetDataType configuration = AdapterTestHelpers.PublishedDataSet(
                "Withdrawn", AdapterTestHelpers.Variable.Value(new NodeId(602u)));
            await using var builder = new DataSetMetaDataBuilder(
                configuration, session.Object, AdapterTestHelpers.Telemetry());
            int notifications = 0;
            builder.MetaDataChanged += (_, _) => notifications++;
            Task<DataSetMetaDataType> resolution = builder.ResolveAsync().AsTask();
            await readStarted.Task.ConfigureAwait(false);

            Task retirement = builder.DisposeAsync().AsTask();
            bool waitingForRead = !retirement.IsCompleted;
            session.Raise(s => s.ModelChanged += null, EventArgs.Empty);
            releaseRead.TrySetResult(
            [
                new DataValue(Variant.From(DataTypeIds.Int32)),
                new DataValue(ValueRanks.Scalar),
                new DataValue(Variant.From(ArrayOf<uint>.Empty))
            ]);
            await resolution.ConfigureAwait(false);
            await retirement.ConfigureAwait(false);

            Assert.That(waitingForRead, Is.True);
            Assert.That(notifications, Is.Zero);
            session.Verify(s => s.ReadAsync(
                It.IsAny<ArrayOf<ReadValueId>>(), It.IsAny<CancellationToken>()), Times.Once);
            await Assert.ThatAsync(
                async () => await builder.RefreshAsync().ConfigureAwait(false),
                Throws.TypeOf<ObjectDisposedException>());
        }

        [Test]
        public void SampleCanceledThrows()
        {
            PublishedDataSetDataType config = AdapterTestHelpers.PublishedDataSet(
                "PDS", AdapterTestHelpers.Variable.Value(new NodeId(11u)));
            var source = new ServerPublishedDataSetSource(
                config,
                new RecordingReadStrategy([]),
                MetaDataBuilder(),
                AdapterTestHelpers.Telemetry());
            using var cts = new CancellationTokenSource();
            cts.Cancel();

            Assert.That(
                async () => await source.SampleAsync(MetaWithFields("A"), cts.Token).ConfigureAwait(false),
                Throws.InstanceOf<OperationCanceledException>());
        }

        [Test]
        public void SourceForwardsMetaDataChangedFromBuilder()
        {
            var builder = new Mock<IDataSetMetaDataBuilder>();
            builder.Setup(b => b.BuildMetaData()).Returns(new DataSetMetaDataType { Name = "Meta" });
            builder.Setup(b => b.ResolveAsync(It.IsAny<CancellationToken>()))
                .Returns(new ValueTask<DataSetMetaDataType>(new DataSetMetaDataType()));
            var source = new ServerPublishedDataSetSource(
                new PublishedDataSetDataType(),
                new RecordingReadStrategy([]),
                builder.Object,
                AdapterTestHelpers.Telemetry());
            int changeCount = 0;
            source.MetaDataChanged += (_, _) => changeCount++;

            builder.Raise(b => b.MetaDataChanged += null, EventArgs.Empty);

            Assert.That(changeCount, Is.EqualTo(1));
        }
    }
}