Merge pull request #63 from nullinside-development-group/feat/history

feat: keeping a history of chat messages

Author: ProgrammingByPermutation

src/TwitchStreamingTools/Models/TwitchChatMessage.cs

@@ -0,0 +1,42 @@
+using System;
+
+namespace TwitchStreamingTools.Models;
+
+/// <summary>
+///   A message sent in twitch chat.
+/// </summary>
+public class TwitchChatMessage {
+  /// <summary>
+  ///   Initializes a new instance of the <see cref="TwitchChatMessage" />.
+  /// </summary>
+  /// <param name="channel">The channel to the message was sent in.</param>
+  /// <param name="username">The username of the sender.</param>
+  /// <param name="message">The chat message.</param>
+  /// <param name="timestamp">The timestamp of when the message was sent.</param>
+  public TwitchChatMessage(string channel, string username, string message, DateTime timestamp) {
+    Channel = channel;
+    Username = username;
+    Message = message;
+    Timestamp = timestamp;
+  }
+
+  /// <summary>
+  ///   The channel to the message was sent in.
+  /// </summary>
+  public string Channel { get; set; }
+
+  /// <summary>
+  ///   The username of the sender.
+  /// </summary>
+  public string Username { get; set; }
+
+  /// <summary>
+  ///   The chat message.
+  /// </summary>
+  public string Message { get; set; }
+
+  /// <summary>
+  ///   The timestamp of when the message was sent.
+  /// </summary>
+  public DateTime Timestamp { get; set; }
+}

src/TwitchStreamingTools/ServiceCollectionExtensions.cs

@@ -5,6 +5,7 @@
 using Nullinside.Api.Common.Twitch;
 
 using TwitchStreamingTools.Services;
+using TwitchStreamingTools.Utilities;
 using TwitchStreamingTools.ViewModels;
 using TwitchStreamingTools.ViewModels.Pages;
 
@@ -19,11 +20,16 @@ public static class ServiceCollectionExtensions {
   /// </summary>
   /// <param name="collection">The services collection to initialize.</param>
   public static void AddCommonServices(this IServiceCollection collection) {
-    collection.AddSingleton<ITwitchAccountService, TwitchAccountService>();
+    // Regular stuff
+    collection.AddSingleton<IConfiguration, Configuration>(_ => Configuration.Instance);
     collection.AddSingleton<ITwitchClientProxy, TwitchClientProxy>(_ => TwitchClientProxy.Instance);
+    collection.AddSingleton<ITwitchChatLog, TwitchChatLog>();
+
+    // Services
+    collection.AddSingleton<ITwitchAccountService, TwitchAccountService>();
     collection.AddSingleton<ITwitchTtsService, TwitchTtsService>();
-    collection.AddSingleton<IConfiguration, Configuration>(_ => Configuration.Instance);
 
+    // View models
     collection.AddTransient<MainWindowViewModel>();
     collection.AddTransient<AccountViewModel>();
     collection.AddTransient<ChatViewModel>();

src/TwitchStreamingTools/Services/TwitchTtsService.cs

@@ -8,6 +8,7 @@
 using Nullinside.Api.Common.Twitch;
 
 using TwitchStreamingTools.Tts;
+using TwitchStreamingTools.Utilities;
 
 namespace TwitchStreamingTools.Services;
 
@@ -40,6 +41,11 @@ public class TwitchTtsService : ITwitchTtsService {
   /// </summary>
   private readonly Thread _thread;
 
+  /// <summary>
+  ///   The twitch chat log.
+  /// </summary>
+  private readonly ITwitchChatLog _twitchChatLog;
+
   /// <summary>
   ///   The twitch chat client to forward chat messages from.
   /// </summary>
@@ -50,9 +56,11 @@ public class TwitchTtsService : ITwitchTtsService {
   /// </summary>
   /// <param name="twitchClientProxy">The twitch chat client.</param>
   /// <param name="configuration">The application configuration.</param>
-  public TwitchTtsService(ITwitchClientProxy twitchClientProxy, IConfiguration configuration) {
+  /// <param name="twitchChatLog">The twitch chat log.</param>
+  public TwitchTtsService(ITwitchClientProxy twitchClientProxy, IConfiguration configuration, ITwitchChatLog twitchChatLog) {
     _configuration = configuration;
     _twitchClientProxy = twitchClientProxy;
+    _twitchChatLog = twitchChatLog;
     _thread = new Thread(Main) {
       IsBackground = true
     };
@@ -96,7 +104,7 @@ private void ConnectChatsInConfig() {
     }
 
     foreach (string? newChat in missing) {
-      var tts = new TwitchChatTts(_configuration, _twitchClientProxy, _configuration.TwitchChats?.FirstOrDefault(t => t.TwitchChannel == newChat));
+      var tts = new TwitchChatTts(_configuration, _twitchClientProxy, _configuration.TwitchChats?.FirstOrDefault(t => t.TwitchChannel == newChat), _twitchChatLog);
       tts.Connect();
       _chats?.Add(tts);
     }

src/TwitchStreamingTools/Tts/TwitchChatTts.cs

@@ -75,10 +75,16 @@ public class TwitchChatTts : IDisposable, ITwitchChatTts {
   /// </summary>
   private ManualResetEvent? _ttsSoundOutputSignal;
 
+  /// <summary>
+  ///   The twitch chat log.
+  /// </summary>
+  public ITwitchChatLog _twitchChatLog;
+
   /// <summary>
   ///   Initializes a new instance of the <see cref="TwitchChatTts" /> class.
   /// </summary>
-  public TwitchChatTts(IConfiguration configuration, ITwitchClientProxy twitchClient, TwitchChatConfiguration? config) {
+  public TwitchChatTts(IConfiguration configuration, ITwitchClientProxy twitchClient, TwitchChatConfiguration? config, ITwitchChatLog twitchChatLog) {
+    _twitchChatLog = twitchChatLog;
     _configuration = configuration;
     _twitchClient = twitchClient;
     ChatConfig = config;
@@ -321,6 +327,7 @@ private void Client_OnMessageReceived(OnMessageReceivedArgs e) {
     Console.WriteLine($"Adding: {e.ChatMessage.Username} says {e.ChatMessage.Message}");
     try {
       _soundsToPlay.Add(e);
+      _twitchChatLog.AddMessage(new TwitchChatMessage(e.ChatMessage.Channel, e.ChatMessage.Username, e.ChatMessage.Message, e.GetTimestamp() ?? DateTime.UtcNow));
     }
     catch (Exception ex) {
       Console.WriteLine($"Failed to add: {e.ChatMessage.Username} says {e.ChatMessage.Message}\r\n{ex}");

src/TwitchStreamingTools/Utilities/ITwitchChatLog.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+
+using TwitchStreamingTools.Models;
+
+namespace TwitchStreamingTools.Utilities;
+
+/// <summary>
+///   The contract for a logger that keeps old twitch messages.
+/// </summary>
+public interface ITwitchChatLog {
+  /// <summary>
+  ///   The maximum number of messages to keep in the log, anything larger than this number will be deleted starting with
+  ///   the oldest messages.
+  /// </summary>
+  public int MaximumMessageCount { get; set; }
+
+  /// <summary>
+  ///   The maximum message age before the message should be deleted, anything older than this will be deleted starting
+  ///   with the oldest messages.
+  /// </summary>
+  public TimeSpan MaximumMessageAge { get; set; }
+
+  /// <summary>
+  ///   Retrieves all messages.
+  /// </summary>
+  /// <param name="channel">If set, filter messages to those sent in a channel, otherwise all channels.</param>
+  /// <returns>All known twitch messages.</returns>
+  public IEnumerable<TwitchChatMessage> GetMessages(string? channel = null);
+
+  /// <summary>
+  ///   Adds a twitch chat log.
+  /// </summary>
+  /// <param name="message">The chat messages.</param>
+  public void AddMessage(TwitchChatMessage message);
+}

src/TwitchStreamingTools/Utilities/TwitchChatLog.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+using Newtonsoft.Json;
+
+using TwitchStreamingTools.Models;
+
+namespace TwitchStreamingTools.Utilities;
+
+/// <summary>
+///   A logger that keeps old twitch messages.
+/// </summary>
+public class TwitchChatLog : ITwitchChatLog {
+  /// <summary>
+  ///   The location of the log file.
+  /// </summary>
+  private static readonly string FILE_LOCATION =
+    Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "nullinside",
+      "twitch-streaming-tools", "twitch-log.json");
+
+  /// <summary>
+  ///   The twitch chat messages collection.
+  /// </summary>
+  private readonly List<TwitchChatMessage> _messages = new();
+
+  /// <summary>
+  ///   Initializes a new instance of the <see cref="TwitchChatLog" /> class.
+  /// </summary>
+  public TwitchChatLog() {
+    _messages.AddRange(ReadLog() ?? []);
+  }
+
+  /// <inheritdoc />
+  public int MaximumMessageCount { get; set; } = 100000;
+
+  /// <inheritdoc />
+  public TimeSpan MaximumMessageAge { get; set; } = TimeSpan.FromDays(7);
+
+  /// <inheritdoc />
+  public IEnumerable<TwitchChatMessage> GetMessages(string? channel = null) {
+    lock (_messages) {
+      return channel == null
+        ? _messages.ToList()
+        : _messages.Where(m => m.Channel == channel).ToList();
+    }
+  }
+
+  /// <inheritdoc />
+  public void AddMessage(TwitchChatMessage message) {
+    lock (_messages) {
+      _messages.Add(message);
+
+      DateTime currentTime = DateTime.Now;
+      _messages.RemoveAll(m => currentTime - m.Timestamp > MaximumMessageAge);
+
+      if (_messages.Count > MaximumMessageCount) {
+        _messages.RemoveRange(0, _messages.Count - MaximumMessageCount);
+      }
+    }
+
+    WriteLog();
+  }
+
+  /// <summary>
+  ///   Reads the log from disk.
+  /// </summary>
+  /// <returns>The log if successful, null otherwise.</returns>
+  private static IEnumerable<TwitchChatMessage>? ReadLog() {
+    try {
+      string json = File.ReadAllText(FILE_LOCATION);
+      return JsonConvert.DeserializeObject<IEnumerable<TwitchChatMessage>>(json);
+    }
+    catch { return null; }
+  }
+
+  /// <summary>
+  ///   Writes the log file to disk.
+  /// </summary>
+  /// <returns>True if successful, false otherwise.</returns>
+  private bool WriteLog() {
+    try {
+      Directory.CreateDirectory(Path.GetDirectoryName(FILE_LOCATION)!);
+
+      string json;
+      lock (_messages) {
+        json = JsonConvert.SerializeObject(_messages);
+      }
+
+      File.WriteAllText(FILE_LOCATION, json);
+      return true;
+    }
+    catch {
+      return false;
+    }
+  }
+}

src/TwitchStreamingTools/ViewModels/Pages/ChatViewModel.cs

@@ -1,7 +1,9 @@
 using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Reactive;
+using System.Text;
 using System.Threading.Tasks;
 
 using Avalonia;
@@ -15,6 +17,7 @@
 using TwitchLib.Client.Events;
 
 using TwitchStreamingTools.Models;
+using TwitchStreamingTools.Utilities;
 
 namespace TwitchStreamingTools.ViewModels.Pages;
 
@@ -27,6 +30,11 @@ public class ChatViewModel : PageViewModelBase, IDisposable {
   /// </summary>
   private readonly IConfiguration _configuration;
 
+  /// <summary>
+  ///   The twitch chat log.
+  /// </summary>
+  private readonly ITwitchChatLog _twitchChatLog;
+
   /// <summary>
   ///   The twitch chat client.
   /// </summary>
@@ -57,7 +65,9 @@ public class ChatViewModel : PageViewModelBase, IDisposable {
   /// </summary>
   /// <param name="twitchClient">The twitch chat client.</param>
   /// <param name="configuration">The application configuration.</param>
-  public ChatViewModel(ITwitchClientProxy twitchClient, IConfiguration configuration) {
+  /// <param name="twitchChatLog">The twitch chat log.</param>
+  public ChatViewModel(ITwitchClientProxy twitchClient, IConfiguration configuration, ITwitchChatLog twitchChatLog) {
+    _twitchChatLog = twitchChatLog;
     _twitchClient = twitchClient;
     _configuration = configuration;
 
@@ -196,22 +206,61 @@ from user in _selectedTwitchChatNames
   /// <param name="msg">The message received.</param>
   private void OnChatMessage(OnMessageReceivedArgs msg) {
     if (_selectedTwitchChatNames.Count > 1) {
-      TwitchChat = (TwitchChat + $"({msg.ChatMessage.Channel}) {msg.ChatMessage.Username}: {msg.ChatMessage.Message}").Trim();
+      TwitchChat = (TwitchChat + FormatChatMessage(msg.ChatMessage.Username, msg.ChatMessage.Message, msg.GetTimestamp() ?? DateTime.UtcNow, msg.ChatMessage.Channel)).Trim();
     }
     else {
-      TwitchChat = (TwitchChat + $"{msg.ChatMessage.Username}: {msg.ChatMessage.Message}").Trim();
+      TwitchChat = (TwitchChat + FormatChatMessage(msg.ChatMessage.Username, msg.ChatMessage.Message, msg.GetTimestamp() ?? DateTime.UtcNow)).Trim();
     }
 
     TwitchChat += "\n";
     TextBoxCursorPosition = int.MaxValue;
   }
 
+  /// <summary>
+  ///   Formats a chat message for display.
+  /// </summary>
+  /// <param name="username">The username of the user that sent the message.</param>
+  /// <param name="message">The chat message sent by the user.</param>
+  /// <param name="timestamp">The timestamp of the message, in UTC.</param>
+  /// <param name="channel">The channel the message was sent in, if you want it included.</param>
+  /// <returns>The formatted message.</returns>
+  private string FormatChatMessage(string username, string message, DateTime timestamp, string? channel = null) {
+    return null == channel ? $"[{timestamp:MM/dd/yy H:mm:ss}] {username}: {message}" : $"[{timestamp:MM/dd/yy H:mm:ss}] ({channel}) {username}: {message}";
+  }
+
   /// <summary>
   ///   Handles registering for twitch chat messages while the UI is open.
   /// </summary>
   public override void OnLoaded() {
     base.OnLoaded();
 
+    // Connect to the twitch chats from the configuration.
+    InitializeTwitchChatConnections();
+
+    // Loads the 
+    PopulateChatHistory();
+  }
+
+  /// <summary>
+  ///   Populates the UI with the historic list of chat messages.
+  /// </summary>
+  private void PopulateChatHistory() {
+    // Get the history of messages
+    IEnumerable<TwitchChatMessage> messages = _twitchChatLog.GetMessages();
+
+    // Convert them into a string
+    var sb = new StringBuilder();
+    sb.AppendJoin('\n', messages.Select(l => FormatChatMessage(l.Username, l.Message, l.Timestamp, l.Channel)));
+    sb.Append('\n');
+
+    // Update the UI
+    TwitchChat = sb.ToString();
+  }
+
+  /// <summary>
+  ///   Connects to the twitch chats in the configuration file.
+  /// </summary>
+  private void InitializeTwitchChatConnections() {
     foreach (TwitchChatConfiguration channel in _configuration.TwitchChats ?? []) {
       if (string.IsNullOrWhiteSpace(channel.TwitchChannel)) {
         continue;