lmxopcua/src/ZB.MOM.WW.LmxOpcUa.Host/GalaxyRepository/ChangeDetectionService.cs

using System;
using System.Threading;
using System.Threading.Tasks;
using Serilog;
using ZB.MOM.WW.LmxOpcUa.Host.Domain;

namespace ZB.MOM.WW.LmxOpcUa.Host.GalaxyRepository
{
    /// <summary>
    ///     Polls the Galaxy database for deployment changes and fires OnGalaxyChanged. (GR-003, GR-004)
    /// </summary>
    public class ChangeDetectionService : IDisposable
    {
        private static readonly ILogger Log = Serilog.Log.ForContext<ChangeDetectionService>();
        private readonly int _intervalSeconds;

        private readonly IGalaxyRepository _repository;
        private CancellationTokenSource? _cts;
        private Task? _pollTask;

        /// <summary>
        ///     Initializes a new change detector for Galaxy deploy timestamps.
        /// </summary>
        /// <param name="repository">The repository used to query the latest deploy timestamp.</param>
        /// <param name="intervalSeconds">The polling interval, in seconds, between deploy checks.</param>
        /// <param name="initialDeployTime">An optional deploy timestamp already known at service startup.</param>
        public ChangeDetectionService(IGalaxyRepository repository, int intervalSeconds,
            DateTime? initialDeployTime = null)
        {
            _repository = repository;
            _intervalSeconds = intervalSeconds;
            LastKnownDeployTime = initialDeployTime;
        }

        /// <summary>
        ///     Gets the last deploy timestamp observed by the polling loop.
        /// </summary>
        public DateTime? LastKnownDeployTime { get; private set; }

        /// <summary>
        ///     Stops the polling loop and disposes the underlying cancellation resources.
        /// </summary>
        public void Dispose()
        {
            Stop();
            _cts?.Dispose();
        }

        /// <summary>
        ///     Occurs when a new Galaxy deploy timestamp indicates the OPC UA address space should be rebuilt.
        /// </summary>
        public event Action? OnGalaxyChanged;

        /// <summary>
        ///     Starts the background polling loop that watches for Galaxy deploy changes.
        /// </summary>
        public void Start()
        {
            if (_cts != null)
                Stop();

            _cts = new CancellationTokenSource();
            _pollTask = Task.Run(() => PollLoopAsync(_cts.Token));
            Log.Information("Change detection started (interval={Interval}s)", _intervalSeconds);
        }

        /// <summary>
        ///     Stops the background polling loop.
        /// </summary>
        public void Stop()
        {
            _cts?.Cancel();
            try { _pollTask?.Wait(TimeSpan.FromSeconds(5)); } catch { /* timeout or faulted */ }
            _pollTask = null;
            Log.Information("Change detection stopped");
        }

        private async Task PollLoopAsync(CancellationToken ct)
        {
            // If no initial deploy time was provided, first poll triggers unconditionally
            var firstPoll = LastKnownDeployTime == null;

            while (!ct.IsCancellationRequested)
            {
                try
                {
                    var deployTime = await _repository.GetLastDeployTimeAsync(ct);

                    if (firstPoll)
                    {
                        firstPoll = false;
                        LastKnownDeployTime = deployTime;
                        Log.Information("Initial deploy time: {DeployTime}", deployTime);
                        OnGalaxyChanged?.Invoke();
                    }
                    else if (deployTime != LastKnownDeployTime)
                    {
                        Log.Information("Galaxy deployment change detected: {Previous} → {Current}",
                            LastKnownDeployTime, deployTime);
                        LastKnownDeployTime = deployTime;
                        OnGalaxyChanged?.Invoke();
                    }
                }
                catch (OperationCanceledException)
                {
                    break;
                }
                catch (Exception ex)
                {
                    Log.Warning(ex, "Change detection poll failed, will retry next interval");
                }

                try
                {
                    await Task.Delay(TimeSpan.FromSeconds(_intervalSeconds), ct);
                }
                catch (OperationCanceledException)
                {
                    break;
                }
            }
        }
    }
}