Fix raid detection and use Announcements instead

PenguinTwitchBot.Test/Services/RaidRewardServiceTests.cs

@@ -64,7 +64,8 @@ public RaidRewardServiceTests()
             Message: "penguin raid",
             SubscriberMessage: "penguin sub raid",
             AnnouncementTemplate: "tpl",
-            PostAnnouncement: true);
+            PostAnnouncement: true,
+            PostPreRaidAnnouncement: true);
 
         private async Task StartAndOpenRaidWindowAsync(RaidRewardConfig config, List<string>? current = null, List<string>? active = null)
         {
@@ -217,5 +218,30 @@ await _moderationClient.DidNotReceive().CreateEventSubSubscriptionDetailedAsync(
                 Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(),
                 Arg.Any<Dictionary<string, string>>(), Arg.Any<EventSubTransportMethod>(), Arg.Any<string>());
         }
+
+        [Fact]
+        public async Task PreRaidReminder_SupersededByNewerRaid_DoesNotPost()
+        {
+            // Interleaving: reminder for raid A pauses during settings retrieval; a newer
+            // raid B starts (bumping the generation); A's callback must not post.
+            var config = DefaultConfig();
+            var settingsTcs = new TaskCompletionSource<RaidRewardConfig>();
+            _settings.GetConfigAsync().Returns(settingsTcs.Task);
+            _pointsSystem.GetPointTypeById(config.PointTypeId).Returns(new PointType { Id = config.PointTypeId, Name = "Points" });
+            await _service.StartAsync(CancellationToken.None);
+
+            // Fire the reminder callback for raid A with a stale generation (0). It will block on settings.
+            var reminderTask = _service.SendPreRaidReminderAsync("RaidA", 0);
+
+            // A newer raid starts, bumping the generation past the stale one. This also awaits
+            // settings, so run it without awaiting to avoid deadlock on the shared TCS.
+            var newRaidTask = _service.AnnounceRaidInitiatedAsync("RaidB"); // bumps generation to 1, then blocks on settings
+
+            // Complete settings; A's callback re-checks generation (now stale) and bails before posting.
+            settingsTcs.SetResult(config);
+            await Task.WhenAll(reminderTask, newRaidTask);
+
+            await _twitchService.DidNotReceive().Announcement(Arg.Is<string>(m => m.Contains("RaidA")));
+        }
     }
 }

PenguinTwitchBot/Pages/Settings/RaidRewards.razor

@@ -58,6 +58,8 @@
 
                 <MudSwitch T="bool" @bind-Value="_postAnnouncement" Label="Post announcement in my chat when the raid starts" Color="Color.Primary" />
 
+                <MudSwitch T="bool" @bind-Value="_postPreRaidAnnouncement" Label="Post announcement in my chat when raid is initiated (!raid command)" Color="Color.Primary" />
+
                 <MudTextField @bind-Value="_announcementTemplate" Label="Announcement template"
                               Variant="Variant.Outlined" Lines="3"
                               HelperText="Placeholders: {target} {message} {submessage} {minutes} {points} {pointtype}" />
@@ -85,6 +87,7 @@
     private string _subscriberMessage = string.Empty;
     private string _announcementTemplate = string.Empty;
     private bool _postAnnouncement;
+    private bool _postPreRaidAnnouncement;
     private bool _saving;
 
     protected override async Task OnInitializedAsync()
@@ -99,6 +102,7 @@
         _subscriberMessage = _config.SubscriberMessage ?? string.Empty;
         _announcementTemplate = _config.AnnouncementTemplate;
         _postAnnouncement = _config.PostAnnouncement;
+        _postPreRaidAnnouncement = _config.PostPreRaidAnnouncement;
         _selectedPointType = _pointTypes.FirstOrDefault(pt => pt.Id == _config.PointTypeId);
     }
 
@@ -121,7 +125,8 @@
                 Message: _message,
                 SubscriberMessage: string.IsNullOrWhiteSpace(_subscriberMessage) ? null : _subscriberMessage,
                 AnnouncementTemplate: _announcementTemplate,
-                PostAnnouncement: _postAnnouncement);
+                PostAnnouncement: _postAnnouncement,
+                PostPreRaidAnnouncement: _postPreRaidAnnouncement);
 
             await RaidRewardSettings.SaveConfigAsync(config);
             Snackbar.Add("Raid Reward settings saved.", Severity.Success);

PenguinTwitchBot/Services/RaidRewardService.cs

@@ -58,6 +58,8 @@
         private readonly object _windowLock = new();
         private RaidWindow? _activeWindow;
         private Timer? _expiryTimer;
+        private Timer? _preRaidReminderTimer;
+        private int _preRaidReminderGeneration;
 
         public RaidRewardService(
             ILogger<RaidRewardService> logger,
@@ -95,6 +97,7 @@
         {
             _serviceBackbone.OutgoingRaidEvent -= OnOutgoingRaid;
             _eventSubClient.ChannelChatMessage -= OnChannelChatMessage;
+            CancelPreRaidReminder();
             await CloseActiveWindowAsync();
         }
 
@@ -107,23 +110,91 @@
             try
             {
                 var config = await _settings.GetConfigAsync();
-                if (!config.Enabled || !config.PostAnnouncement)
+                if (!config.Enabled || !config.PostPreRaidAnnouncement)
                     return;
                 if (string.IsNullOrWhiteSpace(config.Message))
                     return;
 
-                var pointTypeName = await GetPointTypeNameAsync(config.PointTypeId);
-                var message = BuildAnnouncement(config, targetDisplayName, pointTypeName);
-                await _serviceBackbone.SendChatMessage(message);
+                await PostAnnouncementAsync(targetDisplayName, config, "pre-raid");
+                StartPreRaidReminder(targetDisplayName);
             }
             catch (Exception ex)
             {
                 // Never let announcement failures (settings, point lookup, chat dispatch)
                 // propagate to RaidTracker.Raid and prevent the raid from starting.
-                _logger.LogError(ex, "Raid reward: failed to post announcement for {Target}", targetDisplayName);
+                _logger.LogError(ex, "Raid reward: failed to post pre-raid announcement for {Target}", targetDisplayName);
+            }
+        }
+
+        private void StartPreRaidReminder(string targetDisplayName)
+        {
+            CancelPreRaidReminder();
+            var generation = Interlocked.Increment(ref _preRaidReminderGeneration);
+            _preRaidReminderTimer = new Timer(_ => _ = SendPreRaidReminderAsync(targetDisplayName, generation), null, TimeSpan.FromSeconds(30), Timeout.InfiniteTimeSpan);
+        }
+
+        private void CancelPreRaidReminder()
+        {
+            Interlocked.Increment(ref _preRaidReminderGeneration);
+            _preRaidReminderTimer?.Dispose();
+            _preRaidReminderTimer = null;
+        }
+
+        private bool IsCurrentReminder(int generation)
+            => generation == _preRaidReminderGeneration;
+
+        private void CancelPreRaidReminderIfCurrent(int generation)
+        {
+            if (!IsCurrentReminder(generation)) return;
+            var timer = _preRaidReminderTimer;
+            _preRaidReminderTimer = null;
+            timer?.Dispose();
+        }
+
+        internal async Task SendPreRaidReminderAsync(string targetDisplayName, int generation)
+        {
+            try
+            {
+                // Skip if the raid already fired (a window is open) or a newer raid superseded this reminder.
+                lock (_windowLock)
+                {
+                    if (_activeWindow != null || !IsCurrentReminder(generation))
+                    {
+                        CancelPreRaidReminderIfCurrent(generation);
+                        return;
+                    }
+                }
+
+                var config = await _settings.GetConfigAsync();
+                if (!IsCurrentReminder(generation)) return;
+
+                if (!config.Enabled || !config.PostPreRaidAnnouncement || string.IsNullOrWhiteSpace(config.Message))
+                {
+                    CancelPreRaidReminderIfCurrent(generation);
+                    return;
+                }
+
+                if (!IsCurrentReminder(generation)) return;
+                await PostAnnouncementAsync(targetDisplayName, config, "pre-raid reminder");
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Raid reward: failed to post pre-raid reminder for {Target}", targetDisplayName);
+            }
+            finally
+            {
+                CancelPreRaidReminderIfCurrent(generation);
             }
         }
 
+        private async Task PostAnnouncementAsync(string targetDisplayName, RaidRewardConfig config, string kind)
+        {
+            var pointTypeName = await GetPointTypeNameAsync(config.PointTypeId);
+            var message = BuildAnnouncement(config, targetDisplayName, pointTypeName);
+            await _twitchService.Announcement(message);
+            _logger.LogInformation("Raid reward: posted {Kind} announcement for {Target}", kind, targetDisplayName);
+        }
+
         internal async Task OnOutgoingRaid(object? sender, OutgoingRaidEventArgs e)
         {
             try
@@ -149,6 +220,9 @@
                     Config = config
                 };
 
+                // The raid fired; no need for the pre-raid reminder anymore.
+                CancelPreRaidReminder();
+
                 // Close any prior window (deleting its chat subscription) before swapping in the new one.
                 await CloseActiveWindowAsync();
 
@@ -174,6 +248,18 @@
 
                 _logger.LogInformation("Raid reward window opened for {Target} until {Expiry} with {Count} eligible viewers",
                     e.TargetDisplayName, window.ExpiresAtUtc, eligible.Count);
+
+                if (config.PostAnnouncement)
+                {
+                    try
+                    {
+                        await PostAnnouncementAsync(e.TargetDisplayName, config, "raid-start");
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, "Raid reward: failed to post raid-start announcement for {Target}", e.TargetDisplayName);
+                    }
+                }
             }
             catch (Exception ex)
             {
@@ -242,41 +328,96 @@
                 return;
 
             var evt = e.Event;
+            var text = evt.Message.Text ?? string.Empty;
+
+            _logger.LogInformation("Raid reward chat received (window for {Target}): Chatter={Chatter} ({ChatterId}) BroadcasterId={BId} TargetId={TId} Text='{Text}'",
+                window.TargetDisplayName, evt.ChatterUserLogin, evt.ChatterUserId, evt.BroadcasterUserId, window.TargetUserId, text);
 
             // Only count messages that actually occurred in the raided channel. Verified:
             // broadcaster_user_id is the channel we joined/raided; in a shared-chat session,
             // messages from OTHER (guest) channels report a different broadcaster_user_id,
             // while source_broadcaster_user_id stays null for direct messages. So filtering
             // on broadcaster_user_id == the raided target correctly scopes to that channel.
             if (!string.Equals(evt.BroadcasterUserId, window.TargetUserId, StringComparison.OrdinalIgnoreCase))
+            {
+                _logger.LogDebug("Raid reward chat ignored: BroadcasterUserId '{BId}' does not match TargetUserId '{TId}' for {Target}",
+                    evt.BroadcasterUserId, window.TargetUserId, window.TargetDisplayName);
                 return;
+            }
 
             var username = UsernameNormalizer.Normalize(evt.ChatterUserLogin);
+
             if (string.IsNullOrWhiteSpace(username) || !window.EligibleUsernames.Contains(username))
+            {
+                _logger.LogInformation("Raid reward chat from {Chatter} in {Target}: '{Text}' -> SKIPPED (chatter '{ChatterNormalized}' not in pre-raid chatter list of {Count} viewers)",
+                    evt.ChatterUserLogin, window.TargetDisplayName, text, username, window.EligibleUsernames.Count);
                 return;
+            }
 
-            // Match: message contains the configured phrase (case-insensitive). Subs may
-            // also use the optional subscriber phrase.
-            var text = evt.Message.Text ?? string.Empty;
+            // Match: message contains the configured phrase (case-insensitive & punctuation-insensitive).
+            // Subs may also use the optional subscriber phrase.
             var isSub = await _viewerFeature.IsSubscriber(username);
             var matched = ContainsPhrase(text, window.Config.Message);
             if (!matched && isSub && !string.IsNullOrWhiteSpace(window.Config.SubscriberMessage))
                 matched = ContainsPhrase(text, window.Config.SubscriberMessage);
 
             if (!matched)
+            {
+                _logger.LogInformation("Raid reward chat from {Chatter} in {Target}: '{Text}' -> NO MATCH for phrase '{Message}' (subPhrase='{SubMessage}', isSub={IsSub})",
+                    evt.ChatterUserLogin, window.TargetDisplayName, text, window.Config.Message, window.Config.SubscriberMessage ?? "", isSub);
                 return;
+            }
 
             // Award once per raid event. Reserve atomically for concurrency; roll back on failure.
             if (!window.AwardedUsernames.Add(username))
+            {
+                _logger.LogInformation("Raid reward chat from {Chatter} in {Target}: '{Text}' -> ALREADY AWARDED in this raid",
+                    evt.ChatterUserLogin, window.TargetDisplayName, text);
                 return;
+            }
+
+            _logger.LogInformation("Raid reward chat from {Chatter} in {Target}: '{Text}' -> MATCHED! Awarding points...",
+                evt.ChatterUserLogin, window.TargetDisplayName, text);
 
             var awarded = await AwardAsync(window, username, evt.ChatterUserId, evt.ChatterUserName);
             if (!awarded)
                 window.AwardedUsernames.Remove(username);
         }
 
         private static bool ContainsPhrase(string text, string phrase)
-            => text.Contains(phrase, StringComparison.OrdinalIgnoreCase);
+        {
+            if (string.IsNullOrWhiteSpace(phrase) || string.IsNullOrWhiteSpace(text))
+                return false;
+
+            // 1. Direct case-insensitive substring match
+            if (text.Contains(phrase, StringComparison.OrdinalIgnoreCase))
+                return true;
+
+            // 2. Normalized match (strip non-alphanumeric punctuation and collapse extra spaces)
+            var normText = NormalizeForMatching(text);
+            var normPhrase = NormalizeForMatching(phrase);
+
+            if (string.IsNullOrWhiteSpace(normPhrase))
+                return false;
+
+            return normText.Contains(normPhrase, StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static string NormalizeForMatching(string input)
+        {
+            if (string.IsNullOrWhiteSpace(input))
+                return string.Empty;
+
+            var sb = new System.Text.StringBuilder(input.Length);
+            foreach (var c in input)
+            {
+                if (char.IsLetterOrDigit(c) || c == '_')
+                    sb.Append(c);
+                else
+                    sb.Append(' ');
+            }
+            return System.Text.RegularExpressions.Regex.Replace(sb.ToString(), @"\s+", " ").Trim().ToLowerInvariant();
+        }
 
         private async Task<bool> AwardAsync(RaidWindow window, string username, string chatterUserId, string chatterDisplayName)
         {

PenguinTwitchBot/Services/RaidRewardSettingsService.cs

@@ -12,7 +12,8 @@ public sealed record RaidRewardConfig(
     string Message,
     string? SubscriberMessage,
     string AnnouncementTemplate,
-    bool PostAnnouncement);
+    bool PostAnnouncement,
+    bool PostPreRaidAnnouncement);
 
 public interface IRaidRewardSettingsService
 {
@@ -34,6 +35,7 @@ public class RaidRewardSettingsService(IServiceScopeFactory scopeFactory) : IRai
     public const string SubscriberMessageName = "RaidRewardSubscriberMessage";
     public const string AnnouncementTemplateName = "RaidRewardAnnouncementTemplate";
     public const string PostAnnouncementName = "RaidRewardPostAnnouncement";
+    public const string PostPreRaidAnnouncementName = "RaidRewardPostPreRaidAnnouncement";
 
     public const string DefaultMessage = "TombRaid twitchRaid";
 
@@ -47,7 +49,7 @@ public async Task<RaidRewardConfig> GetConfigAsync()
         var settings = await db.Settings.GetAsync(x =>
             x.Name == EnabledName || x.Name == PointTypeIdName || x.Name == PointsToAwardName ||
             x.Name == TimeWindowMinutesName || x.Name == MessageName || x.Name == SubscriberMessageName ||
-            x.Name == AnnouncementTemplateName || x.Name == PostAnnouncementName);
+            x.Name == AnnouncementTemplateName || x.Name == PostAnnouncementName || x.Name == PostPreRaidAnnouncementName);
         var map = settings.ToDictionary(x => x.Name, x => x);
 
         return new RaidRewardConfig(
@@ -62,7 +64,8 @@ public async Task<RaidRewardConfig> GetConfigAsync()
             AnnouncementTemplate: string.IsNullOrWhiteSpace(GetString(map, AnnouncementTemplateName))
                 ? DefaultAnnouncementTemplate
                 : GetString(map, AnnouncementTemplateName),
-            PostAnnouncement: GetInt(map, PostAnnouncementName, 1) == 1);
+            PostAnnouncement: GetInt(map, PostAnnouncementName, 1) == 1,
+            PostPreRaidAnnouncement: GetInt(map, PostPreRaidAnnouncementName, 0) == 1);
     }
 
     public async Task SaveConfigAsync(RaidRewardConfig config)
@@ -78,6 +81,7 @@ public async Task SaveConfigAsync(RaidRewardConfig config)
         await UpsertString(db, SubscriberMessageName, config.SubscriberMessage ?? string.Empty);
         await UpsertString(db, AnnouncementTemplateName, config.AnnouncementTemplate);
         await UpsertInt(db, PostAnnouncementName, config.PostAnnouncement ? 1 : 0);
+        await UpsertInt(db, PostPreRaidAnnouncementName, config.PostPreRaidAnnouncement ? 1 : 0);
 
         await db.SaveChangesAsync();
     }