feat(platform): route scheduler notifications through platform messenger

src/GmRelay.Shared/Infrastructure/Scheduling/SessionSchedulerService.cs

@@ -0,0 +1,139 @@
+using GmRelay.Shared.Features.Confirmation.SendConfirmation;
+using GmRelay.Shared.Features.Reminders.SendJoinLink;
+using GmRelay.Shared.Features.Reminders.SendOneHourReminder;
+using GmRelay.Shared.Platform;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace GmRelay.Shared.Infrastructure.Scheduling;
+
+/// <summary>
+/// Stateless scheduler: wakes every 60 seconds, queries PostgreSQL for actionable sessions.
+/// All state is kept in the database so worker restarts do not lose scheduled work.
+/// </summary>
+public sealed class SessionSchedulerService(
+    ISessionTriggerStore triggerStore,
+    ISendConfirmationHandler confirmationHandler,
+    ISendOneHourReminderHandler oneHourReminderHandler,
+    ISendJoinLinkHandler joinLinkHandler,
+    ISystemClock clock,
+    ILogger<SessionSchedulerService> logger) : BackgroundService
+{
+    private static readonly TimeSpan TickInterval = TimeSpan.FromMinutes(1);
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        logger.LogInformation("Session scheduler started (interval: {Interval})", TickInterval);
+
+        using var timer = new PeriodicTimer(TickInterval);
+
+        do
+        {
+            try
+            {
+                await TickAsync(stoppingToken);
+            }
+            catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+            {
+                break;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Scheduler tick failed, will retry next tick");
+            }
+        }
+        while (await timer.WaitForNextTickAsync(stoppingToken));
+
+        logger.LogInformation("Session scheduler stopped");
+    }
+
+    public async Task TickAsync(CancellationToken ct)
+    {
+        var now = clock.UtcNow;
+
+        await ProcessConfirmationTriggers(now, ct);
+        await ProcessOneHourReminderTriggers(now, ct);
+        await ProcessJoinLinkTriggers(now, ct);
+    }
+
+    private async Task ProcessConfirmationTriggers(DateTimeOffset now, CancellationToken ct)
+    {
+        IReadOnlyList<Guid> sessionIds;
+        try
+        {
+            sessionIds = await triggerStore.GetSessionsNeedingConfirmationAsync(now, ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to query confirmation triggers");
+            return;
+        }
+
+        foreach (var sessionId in sessionIds)
+        {
+            try
+            {
+                await confirmationHandler.HandleAsync(sessionId, ct);
+                logger.LogInformation("Confirmation sent for session {SessionId}", sessionId);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Failed to send confirmation for session {SessionId}", sessionId);
+            }
+        }
+    }
+
+    private async Task ProcessOneHourReminderTriggers(DateTimeOffset now, CancellationToken ct)
+    {
+        IReadOnlyList<Guid> sessionIds;
+        try
+        {
+            sessionIds = await triggerStore.GetSessionsNeedingOneHourReminderAsync(now, ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to query one-hour reminder triggers");
+            return;
+        }
+
+        foreach (var sessionId in sessionIds)
+        {
+            try
+            {
+                await oneHourReminderHandler.HandleAsync(sessionId, ct);
+                logger.LogInformation("One-hour reminder processed for session {SessionId}", sessionId);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Failed to process one-hour reminder for session {SessionId}", sessionId);
+            }
+        }
+    }
+
+    private async Task ProcessJoinLinkTriggers(DateTimeOffset now, CancellationToken ct)
+    {
+        IReadOnlyList<Guid> sessionIds;
+        try
+        {
+            sessionIds = await triggerStore.GetSessionsNeedingJoinLinkAsync(now, ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to query join-link triggers");
+            return;
+        }
+
+        foreach (var sessionId in sessionIds)
+        {
+            try
+            {
+                await joinLinkHandler.HandleAsync(sessionId, ct);
+                logger.LogInformation("Join link sent for session {SessionId}", sessionId);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Failed to send join link for session {SessionId}", sessionId);
+            }
+        }
+    }
+}