using System.Collections.Concurrent;
using Microsoft.Data.Sqlite;
using Microsoft.Extensions.Logging.Abstractions;
using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;
using ZB.MOM.WW.ScadaBridge.SiteEventLogging;

namespace ZB.MOM.WW.ScadaBridge.StoreAndForward.Tests;

/// <summary>
/// M1.7: the StoreAndForwardService emits site operational events for its own
/// buffer/park activity — <c>store_and_forward</c> for cached-call categories
/// (ExternalSystem / CachedDbWrite) and <c>notification</c> for the site's
/// notification forward-to-central path. Emission rides the existing
/// <c>OnActivity</c> hook and is best-effort (a failing logger never affects
/// delivery bookkeeping).
/// </summary>
public class StoreAndForwardSiteEventTests : IAsyncLifetime, IDisposable
{
    private sealed record Entry(string EventType, string Severity, string Source, string Message);

    private sealed class FakeSiteEventLogger : ISiteEventLogger
    {
        private readonly ConcurrentQueue<Entry> _entries = new();
        public IReadOnlyList<Entry> Entries => _entries.ToArray();
        public IReadOnlyList<Entry> OfType(string t) => _entries.Where(e => e.EventType == t).ToArray();

        public Task LogEventAsync(string eventType, string severity, string? instanceId,
            string source, string message, string? details = null)
        {
            _entries.Enqueue(new Entry(eventType, severity, source, message));
            return Task.CompletedTask;
        }

        public long FailedWriteCount => 0;
    }

    private readonly SqliteConnection _keepAlive;
    private readonly StoreAndForwardStorage _storage;
    private readonly StoreAndForwardOptions _options;
    private readonly FakeSiteEventLogger _siteLog = new();
    private readonly StoreAndForwardService _service;

    public StoreAndForwardSiteEventTests()
    {
        var dbName = $"SiteEvt_{Guid.NewGuid():N}";
        var connStr = $"Data Source={dbName};Mode=Memory;Cache=Shared";
        _keepAlive = new SqliteConnection(connStr);
        _keepAlive.Open();

        _storage = new StoreAndForwardStorage(connStr, NullLogger<StoreAndForwardStorage>.Instance);
        _options = new StoreAndForwardOptions
        {
            DefaultRetryInterval = TimeSpan.Zero,
            DefaultMaxRetries = 1,
            RetryTimerInterval = TimeSpan.FromMinutes(10)
        };

        _service = new StoreAndForwardService(
            _storage, _options, NullLogger<StoreAndForwardService>.Instance,
            replication: null, cachedCallObserver: null, siteId: "site-a",
            siteEventLogger: _siteLog);
    }

    public async Task InitializeAsync() => await _storage.InitializeAsync();
    public Task DisposeAsync() => Task.CompletedTask;
    public void Dispose() => _keepAlive.Dispose();

    [Fact]
    public async Task BufferForRetry_ExternalSystem_EmitsStoreAndForwardSiteEvent()
    {
        _service.RegisterDeliveryHandler(StoreAndForwardCategory.ExternalSystem,
            _ => throw new HttpRequestException("transient"));

        await _service.EnqueueAsync(StoreAndForwardCategory.ExternalSystem, "api.example.com", """{}""", "Pump1");

        var rows = _siteLog.OfType("store_and_forward");
        Assert.Contains(rows, r => r.Severity == "Warning" &&
            r.Source == "StoreAndForwardService" &&
            r.Message.Contains("queued", StringComparison.OrdinalIgnoreCase));
        // The cached-call categories must NOT surface as notification events.
        Assert.Empty(_siteLog.OfType("notification"));
    }

    [Fact]
    public async Task ForwardFailure_Notification_EmitsNotificationSiteEvent()
    {
        // The site's notification role is forward-to-central. When the immediate
        // forward to central throws (central unreachable), the notification is
        // buffered for retry — a forward FAILURE, which the spec says to log as a
        // `notification` site event (filling the in-transit blind spot).
        _service.RegisterDeliveryHandler(StoreAndForwardCategory.Notification,
            _ => throw new HttpRequestException("central unreachable"));

        await _service.EnqueueAsync(StoreAndForwardCategory.Notification, "list-a", """{}""", "Pump1");

        var rows = _siteLog.OfType("notification");
        Assert.Contains(rows, r => r.Severity == "Warning" &&
            r.Source == "StoreAndForwardService" &&
            r.Message.Contains("queued", StringComparison.OrdinalIgnoreCase));
        // A notification forward-failure is not a store_and_forward (cached-call) event.
        Assert.Empty(_siteLog.OfType("store_and_forward"));
    }

    [Fact]
    public async Task RoutineEnqueue_Notification_DoesNotEmitSiteEvent()
    {
        // Spec: routine enqueue / forward-success on the notification path are
        // deliberately NOT logged — central's Notifications table is the audit
        // record of record. A successful immediate forward emits no site event.
        _service.RegisterDeliveryHandler(StoreAndForwardCategory.Notification,
            _ => Task.FromResult(true));

        await _service.EnqueueAsync(StoreAndForwardCategory.Notification, "list-a", """{}""", "Pump1");

        Assert.Empty(_siteLog.OfType("notification"));
    }

    [Fact]
    public async Task Park_Notification_EmitsErrorNotificationSiteEvent()
    {
        // A long-buffered notification that exhausts retries is parked — the spec
        // logs this as a `notification` event (Error severity).
        _service.RegisterDeliveryHandler(StoreAndForwardCategory.Notification,
            _ => throw new HttpRequestException("central unreachable"));

        await _service.EnqueueAsync(
            StoreAndForwardCategory.Notification, "list-a", """{}""", "Pump1",
            attemptImmediateDelivery: false, maxRetries: 1);

        await _service.RetryPendingMessagesAsync();

        var rows = _siteLog.OfType("notification");
        Assert.Contains(rows, r => r.Severity == "Error" &&
            r.Message.Contains("parked", StringComparison.OrdinalIgnoreCase));
    }

    [Fact]
    public async Task Park_ExternalSystem_EmitsErrorStoreAndForwardSiteEvent()
    {
        // MaxRetries = 1 → the first sweep retry parks the message.
        _service.RegisterDeliveryHandler(StoreAndForwardCategory.ExternalSystem,
            _ => throw new HttpRequestException("transient"));

        await _service.EnqueueAsync(
            StoreAndForwardCategory.ExternalSystem, "api.example.com", """{}""", "Pump1",
            attemptImmediateDelivery: false, maxRetries: 1);

        await _service.RetryPendingMessagesAsync();

        var rows = _siteLog.OfType("store_and_forward");
        Assert.Contains(rows, r => r.Severity == "Error" &&
            r.Message.Contains("parked", StringComparison.OrdinalIgnoreCase));
    }

    [Fact]
    public async Task DeliveredImmediately_DoesNotEmitSiteEvent()
    {
        // A successful immediate delivery is the normal hot path — it is not a
        // store-and-forward buffering event, so no operational event is logged.
        _service.RegisterDeliveryHandler(StoreAndForwardCategory.ExternalSystem,
            _ => Task.FromResult(true));

        await _service.EnqueueAsync(StoreAndForwardCategory.ExternalSystem, "api", """{}""", "Pump1");

        Assert.Empty(_siteLog.OfType("store_and_forward"));
        Assert.Empty(_siteLog.OfType("notification"));
    }
}