Finished routing with automatic help text generation

Changelog: added

MinecraftDiscordBot/ChunkWaiter.cs

@@ -0,0 +1,43 @@
+namespace MinecraftDiscordBot;
+
+public class ChunkWaiter<T> : IChunkWaiter {
+    public int ID { get; }
+    private readonly CancellationToken _ct;
+    public ChunkWaiter(int id, Func<string, T> resultParser, CancellationToken ct) {
+        ID = id;
+        this.resultParser = resultParser;
+        _ct = ct;
+    }
+    private readonly TaskCompletionSource<T> tcs = new();
+    private readonly Func<string, T> resultParser;
+    public Task<T> Task => tcs.Task.WaitAsync(_ct);
+    public bool Finished { get; private set; } = false;
+    public bool IsCancellationRequested => _ct.IsCancellationRequested;
+    private string?[]? _chunks = null;
+    private int _receivedChunks = 0;
+    private bool _success = true;
+    private readonly object _syncRoot = new();
+    public void AddChunk(int chunkId, int totalChunks, string value) {
+        lock (_syncRoot) {
+            if (_chunks is null) _chunks = new string[totalChunks];
+            else if (_chunks.Length != totalChunks) {
+                Program.LogErrorAsync(Program.WebSocketSource, new InvalidOperationException("Different numbers of chunks in same message ID!"));
+                return;
+            }
+            ref string? chunk = ref _chunks[chunkId - 1]; // Lua 1-indexed
+            if (chunk is not null) {
+                Program.LogErrorAsync(Program.WebSocketSource, new InvalidOperationException($"Chunk with ID {chunkId} was already received!"));
+                return;
+            }
+            chunk = value;
+        }
+        if (++_receivedChunks == totalChunks) FinalizeResult(_chunks);
+    }
+    private void FinalizeResult(string?[] _chunks) {
+        var resultString = string.Concat(_chunks);
+        if (_success) tcs.SetResult(resultParser(resultString));
+        else tcs.SetException(new ReplyException(resultString));
+        Finished = true;
+    }
+    public void SetUnsuccessful() => _success = false;
+}

MinecraftDiscordBot/CommandRouter.cs

@@ -0,0 +1,47 @@
+using Discord;
+using Discord.WebSocket;
+using System.Reflection;
+using System.Text;
+
+namespace MinecraftDiscordBot;
+
+public abstract class CommandRouter : ICommandHandler<ResponseType> {
+    private readonly Dictionary<string, HandlerStruct> _handlers = new();
+    public abstract string HelpTextPrefix { get; }
+    public CommandRouter() {
+        foreach (var method in GetType().GetMethods())
+            if (GetHandlerAttribute(method) is CommandHandlerAttribute attribute)
+                try {
+                    _handlers.Add(attribute.CommandName, new(method.CreateDelegate<HandleCommandDelegate<ResponseType>>(this), attribute));
+                } catch (Exception) {
+                    Program.LogWarning("CommandRouter", $"Could not add delegate for method {attribute.CommandName} in function {method.ReturnType} {method.Name}(...)!");
+                    throw;
+                }
+    }
+
+    [CommandHandler("help", HelpText = "Show this help information!")]
+    public virtual Task<ResponseType> GetHelpText(SocketUserMessage message, string[] parameters, CancellationToken ct)
+        => Task.FromResult(ResponseType.AsString(GenerateHelp()));
+    private static CommandHandlerAttribute? GetHandlerAttribute(MethodInfo method)
+        => method.GetCustomAttributes(typeof(CommandHandlerAttribute), true).OfType<CommandHandlerAttribute>().FirstOrDefault();
+    public abstract Task<ResponseType> RootAnswer(SocketUserMessage message, CancellationToken ct);
+    public abstract Task<ResponseType> FallbackHandler(SocketUserMessage message, string method, string[] parameters, CancellationToken ct);
+    public Task<ResponseType> HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct)
+        => parameters is { Length: 0 }
+            ? RootAnswer(message, ct)
+            : _handlers.TryGetValue(parameters[0], out var handler)
+                ? handler.Delegate(message, parameters[1..], ct)
+                : FallbackHandler(message, parameters[0], parameters[1..], ct);
+    private string GenerateHelp() {
+        var sb = new StringBuilder();
+        sb.Append("Command usage:");
+        foreach (var (name, handler) in _handlers) {
+            sb.Append($"\n{HelpTextPrefix}{name}");
+            if (handler.Attribute.HelpText is string help)
+                sb.Append($": {help}");
+        }
+        return sb.ToString();
+    }
+}
+
+public record struct HandlerStruct(HandleCommandDelegate<ResponseType> Delegate, CommandHandlerAttribute Attribute);

MinecraftDiscordBot/ConnectedComputer.cs

@@ -3,179 +3,46 @@ using Discord.WebSocket;
 using Fleck;
 using Newtonsoft.Json;
 using System.Diagnostics;
+using System.Runtime.Serialization;
 using System.Text;
 
 namespace MinecraftDiscordBot;
 
-public class ConnectedComputer {
-    protected readonly IWebSocketConnection _socket;
-    public ConnectedComputer(IWebSocketConnection socket) {
-        socket.OnMessage = OnMessage;
-        _socket = socket;
+public delegate Task<TResponse> HandleCommandDelegate<TResponse>(SocketUserMessage message, string[] parameters, CancellationToken ct);
+public delegate Task HandleCommandDelegate(SocketUserMessage message, string[] parameters, CancellationToken ct);
+
+[AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
+public sealed class CommandHandlerAttribute : Attribute {
+    public CommandHandlerAttribute(string commandName) => CommandName = commandName;
+    public string CommandName { get; }
+    public string? HelpText { get; init; }
 }
 
-    private void OnMessage(string message) {
-        if (JsonConvert.DeserializeObject<ReplyMessage>(message) is not ReplyMessage msg) return;
-        IChunkWaiter? waiter;
-        lock (_syncRoot) {
-            if (!_waits.TryGetValue(msg.AnswerId, out waiter)) {
-                Program.LogWarning("Socket", $"Invalid wait id '{msg.AnswerId}'!");
-                return;
-            }
-        }
-        waiter.AddChunk(msg.Chunk, msg.Total, msg.Result);
-        if (waiter.Finished || waiter.IsCancellationRequested)
-            lock (_syncRoot)
-                _waits.Remove(waiter.ID);
-    }
-    public Task Send(string message) => _socket.Send(message);
-    protected Task Send(Message message) => Send(JsonConvert.SerializeObject(message));
-    private readonly object _syncRoot = new();
-    private readonly Dictionary<int, IChunkWaiter> _waits = new();
-    private readonly Random _rnd = new();
-    public IWebSocketConnectionInfo ConnectionInfo => _socket.ConnectionInfo;
+public class RefinedStorageService : CommandRouter {
+    private readonly ITaskWaitSource _taskSource;
+    public override string HelpTextPrefix => "!rs ";
+    public RefinedStorageService(ITaskWaitSource taskSource) : base() => _taskSource = taskSource;
+    public override Task<ResponseType> FallbackHandler(SocketUserMessage message, string method, string[] parameters, CancellationToken ct)
+        => Task.FromResult(ResponseType.AsString($"The RS system has no command '{method}'!"));
+    public override Task<ResponseType> RootAnswer(SocketUserMessage message, CancellationToken ct)
+        => Task.FromResult(ResponseType.AsString("The RS system is online!"));
 
-    protected interface IChunkWaiter {
-        bool Finished { get; }
-        int ID { get; }
-        bool IsCancellationRequested { get; }
-        void AddChunk(int chunkId, int totalChunks, string value);
+    private async Task<T> Method<T>(string methodName, Func<string, T> parser, CancellationToken ct) {
+        var waiter = _taskSource.GetWaiter(parser, ct);
+        await _taskSource.Send(new RequestMessage(waiter.ID, methodName));
+        return await waiter.Task;
     }
 
-    protected class ChunkWaiter<T> : IChunkWaiter {
-        public int ID { get; }
-        private readonly CancellationToken _ct;
-        public ChunkWaiter(int id, Func<string, T> resultParser, CancellationToken ct) {
-            ID = id;
-            this.resultParser = resultParser;
-            _ct = ct;
-        }
-        private readonly TaskCompletionSource<T> tcs = new();
-        private readonly Func<string, T> resultParser;
-        public Task<T> Task => tcs.Task.WaitAsync(_ct);
-        public bool Finished { get; private set; } = false;
-        public bool IsCancellationRequested => _ct.IsCancellationRequested;
-        private string?[]? _chunks = null;
-        private int _receivedChunks = 0;
-        private readonly object _syncRoot = new();
-        public void AddChunk(int chunkId, int totalChunks, string value) {
-            lock (_syncRoot) {
-                if (_chunks is null) _chunks = new string[totalChunks];
-                else if (_chunks.Length != totalChunks) {
-                    Program.LogError(Program.WebSocketSource, new InvalidOperationException("Different numbers of chunks in same message ID!"));
-                    return;
-                }
-                ref string? chunk = ref _chunks[chunkId - 1]; // Lua 1-indexed
-                if (chunk is not null) {
-                    Program.LogError(Program.WebSocketSource, new InvalidOperationException($"Chunk with ID {chunkId} was already received!"));
-                    return;
-                }
-                chunk = value;
-            }
-            if (++_receivedChunks == totalChunks) FinalizeResult(_chunks);
-        }
-        private void FinalizeResult(string?[] _chunks) {
-            tcs.SetResult(resultParser(string.Concat(_chunks)));
-            Finished = true;
-        }
-    }
-
-    protected int GetFreeId() {
-        var attempts = 0;
-        while (true) {
-            var id = _rnd.Next();
-            if (!_waits.ContainsKey(id))
-                return id;
-            Program.LogWarning(Program.WebSocketSource, $"Could not get a free ID after {++attempts} attempts!");
-        }
-    }
-
-    protected ChunkWaiter<T> GetWaiter<T>(Func<string, T> resultParser, CancellationToken ct) {
-        ChunkWaiter<T> waiter;
-        lock (_syncRoot) {
-            waiter = new ChunkWaiter<T>(GetFreeId(), resultParser, ct);
-            _waits.Add(waiter.ID, waiter);
-        }
-        return waiter;
-    }
-
-    protected static Func<string, T> Deserialize<T>() => msg
-         => JsonConvert.DeserializeObject<T>(msg) ?? throw new InvalidProgramException("Empty response!");
-}
-
-public class RefinedStorageComputer : ConnectedComputer {
-    public const string Role = "rs";
     private const string CmdEnergyUsage = "energyusage";
     private const string CmdEnergyStorage = "energystorage";
     private const string CmdListItems = "listitems";
     private const string CmdItemName = "itemname";
     private const string CmdListFluids = "listfluids";
 
-    public RefinedStorageComputer(IWebSocketConnection socket) : base(socket) { }
-    public async Task<int> GetEnergyUsageAsync(CancellationToken ct) {
-        var waiter = GetWaiter(int.Parse, ct);
-        await Send(new RequestMessage(waiter.ID, CmdEnergyUsage));
-        return await waiter.Task;
-    }
-    public async Task<int> GetEnergyStorageAsync(CancellationToken ct) {
-        var waiter = GetWaiter(int.Parse, ct);
-        await Send(new RequestMessage(waiter.ID, CmdEnergyStorage));
-        return await waiter.Task;
-    }
-    public async Task<IEnumerable<Item>> ListItemsAsync(CancellationToken ct) {
-        var waiter = GetWaiter(Deserialize<IEnumerable<Item>>(), ct);
-        await Send(new RequestMessage(waiter.ID, CmdListItems));
-        return await waiter.Task;
-    }
-
-    public async Task<IEnumerable<Fluid>> ListFluidsAsync(CancellationToken ct) {
-        var waiter = GetWaiter(Deserialize<IEnumerable<Fluid>>(), ct);
-        await Send(new RequestMessage(waiter.ID, CmdListFluids));
-        return await waiter.Task;
-    }
-
-    public async Task HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct) {
-        if (parameters is not { Length: > 0 }) {
-            await message.ReplyAsync($"Refined Storage system is online");
-            return;
-        }
-
-        try {
-            switch (parameters[0].ToLower()) {
-            case CmdEnergyUsage:
-                await message.ReplyAsync($"Refined Storage system currently uses {await GetEnergyUsageAsync(ct)} RF/t");
-                break;
-            case CmdEnergyStorage:
-                await message.ReplyAsync($"Refined Storage system stores {await GetEnergyStorageAsync(ct)} RF/t");
-                break;
-            case CmdListItems:
-                await HandleItemListing(message, ct);
-                break;
-            case CmdItemName:
-                await HandleItemName(message, parameters, ct);
-                break;
-            case CmdListFluids:
-                await HandleFluidListing(message, ct);
-                break;
-            case string other:
-                await message.ReplyAsync($"Refined Storages cannot do '{other}', bruh");
-                break;
-            }
-        } catch (TaskCanceledException) {
-            await message.ReplyAsync("The Refined Storage system request timed out!");
-        }
-    }
-
-    private async Task HandleItemName(SocketUserMessage message, string[] parameters, CancellationToken ct) {
-        if (parameters.Length < 2) await message.ReplyAsync($"Usage: {CmdItemName} filters...");
-        else {
-            var items = await FilterItems(message, parameters[1..], ct);
-            var sb = new StringBuilder();
-            sb.AppendLine("Did you mean:");
-            sb.AppendJoin("\n", items.Select(i => i.ToString()));
-            await message.ReplyAsync(sb.ToString());
-        }
-    }
+    public async Task<int> GetEnergyUsageAsync(CancellationToken ct) => await Method(CmdEnergyUsage, int.Parse, ct);
+    public async Task<int> GetEnergyStorageAsync(CancellationToken ct) => await Method(CmdEnergyStorage, int.Parse, ct);
+    public async Task<IEnumerable<Item>> ListItemsAsync(CancellationToken ct) => await Method(CmdListItems, ConnectedComputer.Deserialize<IEnumerable<Item>>(), ct);
+    public async Task<IEnumerable<Fluid>> ListFluidsAsync(CancellationToken ct) => await Method(CmdListFluids, ConnectedComputer.Deserialize<IEnumerable<Fluid>>(), ct);
 
     private Task<IEnumerable<Item>> FilterItems(SocketUserMessage message, IEnumerable<string> filters, CancellationToken ct)
         => FilterItems(message, filters.Select(ItemFilter.Parse), ct);
@@ -188,51 +55,48 @@ public class RefinedStorageComputer : ConnectedComputer {
         return items.ToList();
     }
 
-    public abstract class ItemFilter {
-        public abstract bool Match(Fluid item);
-        public virtual bool MatchItem(Item item) => Match(item);
-
-        public static ItemFilter Parse(string filter)
-            => filter.StartsWith('@')
-                ? new ModNameFilter(filter[1..])
-                : filter.StartsWith('$')
-                ? new TagFilter(filter[1..])
-                : new ItemNameFilter(filter);
-
-        private class ModNameFilter : ItemFilter {
-            private readonly string filter;
-            public ModNameFilter(string filter) => this.filter = filter;
-            public override bool Match(Fluid item) => item.ItemId.ModName.Contains(filter, StringComparison.InvariantCultureIgnoreCase);
-        }
-
-        private class TagFilter : ItemFilter {
-            private readonly string filter;
-            public TagFilter(string filter) => this.filter = filter;
-            public override bool Match(Fluid item)
-                => item.Tags?.Any(tag => tag.Contains(filter, StringComparison.InvariantCultureIgnoreCase)) ?? false;
-        }
-
-        private class ItemNameFilter : ItemFilter {
-            private readonly string filter;
-            public ItemNameFilter(string filter) => this.filter = filter;
-            public override bool Match(Fluid item) => item.DisplayName.Contains(filter, StringComparison.InvariantCultureIgnoreCase);
+    private async Task<List<Item>> RefreshItemList(CancellationToken ct) {
+        var response = await ListItemsAsync(ct);
+        lock (_itemLock) {
+            Items = response.OrderByDescending(i => i.Amount).ToList();
+            return Items;
         }
     }
 
-    private async Task HandleFluidListing(SocketUserMessage message, CancellationToken ct) {
+    private List<Item>? Items;
+    private readonly object _itemLock = new();
+
+    [CommandHandler(CmdEnergyStorage, HelpText = "Get the amount of energy stored in the RS system.")]
+    public async Task<ResponseType> HandleEnergyStorage(SocketUserMessage message, string[] parameters, CancellationToken ct)
+        => ResponseType.AsString($"Refined Storage system stores {await GetEnergyStorageAsync(ct)} RF/t");
+    [CommandHandler(CmdEnergyUsage, HelpText = "Get the amount of energy used by the RS system.")]
+    public async Task<ResponseType> HandleEnergyUsage(SocketUserMessage message, string[] parameters, CancellationToken ct)
+        => ResponseType.AsString($"Refined Storage system currently uses {await GetEnergyUsageAsync(ct)} RF/t");
+    [CommandHandler(CmdItemName, HelpText = "Filter items by name.")]
+    public async Task<ResponseType> HandleItemName(SocketUserMessage message, string[] parameters, CancellationToken ct) {
+        if (parameters.Length < 2) return ResponseType.AsString($"Usage: {CmdItemName} filters...");
+        else {
+            var items = await FilterItems(message, parameters[1..], ct);
+            var sb = new StringBuilder();
+            sb.AppendLine("Did you mean:");
+            sb.AppendJoin("\n", items.Select(i => i.ToString()));
+            return ResponseType.AsString(sb.ToString());
+        }
+    }
+
+    [CommandHandler(CmdListFluids, HelpText = "Gets a list of fluids that are currently stored in the RS system.")]
+    public async Task<ResponseType> HandleFluidListing(SocketUserMessage message, string[] parameters, CancellationToken ct) {
         var sb = new StringBuilder();
         sb.Append("The Refined Storage system stores those fluids:");
         var fluids = await ListFluidsAsync(ct);
         foreach (var fluid in fluids.OrderByDescending(i => i.Amount))
             if (fluid.Amount > 10000) sb.AppendFormat("\n{0:n2} B of {1}", fluid.Amount / 1000.0f, fluid.DisplayName);
             else sb.AppendFormat("\n{0:n0} mB of {1}", fluid.Amount, fluid.DisplayName);
-        await message.ReplyAsync(sb.ToString());
+        return ResponseType.AsString(sb.ToString());
     }
 
-    private List<Item>? Items;
-    private readonly object _itemLock = new();
-
-    private async Task HandleItemListing(SocketUserMessage message, CancellationToken ct) {
+    [CommandHandler(CmdListItems, HelpText = "Gets a list of items that are currently stored in the RS system.")]
+    public async Task<ResponseType> HandleItemListing(SocketUserMessage message, string[] parameters, CancellationToken ct) {
         var sb = new StringBuilder();
         sb.Append("The Refined Storage system currently stores these items:");
         var items = await RefreshItemList(ct);
@@ -245,16 +109,85 @@ public class RefinedStorageComputer : ConnectedComputer {
             }
             if (items.Count > taken) sb.AppendFormat("\nand {0} more items.", items.Skip(taken).Sum(i => i.Amount));
         }
-        await message.ReplyAsync(sb.ToString());
+        return ResponseType.AsString(sb.ToString());
+    }
 }
 
-    private async Task<List<Item>> RefreshItemList(CancellationToken ct) {
-        var response = await ListItemsAsync(ct);
-        lock (_itemLock) {
-            Items = response.OrderByDescending(i => i.Amount).ToList();
-            return Items;
+public class ConnectedComputer : CommandRouter, ITaskWaitSource {
+    protected readonly IWebSocketConnection _socket;
+    public override string HelpTextPrefix => "!";
+    public ConnectedComputer(IWebSocketConnection socket) : base() {
+        socket.OnMessage = OnMessage;
+        _socket = socket;
+        _rs = new RefinedStorageService(this);
+    }
+
+    private void OnMessage(string message) {
+        if (JsonConvert.DeserializeObject<ReplyMessage>(message) is not ReplyMessage msg) return;
+        IChunkWaiter? waiter;
+        lock (_syncRoot) {
+            if (!_waits.TryGetValue(msg.AnswerId, out waiter)) {
+                Program.LogWarningAsync("Socket", $"Invalid wait id '{msg.AnswerId}'!");
+                return;
             }
         }
+        if (!msg.Success) waiter.SetUnsuccessful();
+        waiter.AddChunk(msg.Chunk, msg.Total, msg.Result);
+        if (waiter.Finished || waiter.IsCancellationRequested)
+            lock (_syncRoot)
+                _waits.Remove(waiter.ID);
+    }
+
+    public Task Send(string message) => _socket.Send(message);
+    public Task Send(Message message) => Send(JsonConvert.SerializeObject(message));
+    private readonly object _syncRoot = new();
+    private readonly Dictionary<int, IChunkWaiter> _waits = new();
+    private readonly Random _rnd = new();
+    public IWebSocketConnectionInfo ConnectionInfo => _socket.ConnectionInfo;
+
+    private int GetFreeId() {
+        var attempts = 0;
+        while (true) {
+            var id = _rnd.Next();
+            if (!_waits.ContainsKey(id))
+                return id;
+            Program.LogWarningAsync(Program.WebSocketSource, $"Could not get a free ID after {++attempts} attempts!");
+        }
+    }
+
+    public ChunkWaiter<T> GetWaiter<T>(Func<string, T> resultParser, CancellationToken ct) {
+        ChunkWaiter<T> waiter;
+        lock (_syncRoot) {
+            waiter = new ChunkWaiter<T>(GetFreeId(), resultParser, ct);
+            _waits.Add(waiter.ID, waiter);
+        }
+        return waiter;
+    }
+
+    private readonly ICommandHandler<ResponseType> _rs;
+    [CommandHandler("rs", HelpText ="Provides some commands for interacting with the Refined Storage system.")]
+    public Task<ResponseType> RefinedStorageHandler(SocketUserMessage message, string[] parameters, CancellationToken ct)
+        => _rs.HandleCommand(message, parameters, ct);
+
+    public static Func<string, T> Deserialize<T>() => msg
+             => JsonConvert.DeserializeObject<T>(msg) ?? throw new InvalidProgramException("Empty response!");
+    public override Task<ResponseType> RootAnswer(SocketUserMessage message, CancellationToken ct)
+        => Task.FromResult(ResponseType.AsString("The Minecraft server is connected!"));
+    public override Task<ResponseType> FallbackHandler(SocketUserMessage message, string method, string[] parameters, CancellationToken ct)
+        => Task.FromResult(ResponseType.AsString($"What the fuck do you mean by '{method}'?"));
+}
+
+public interface ITaskWaitSource {
+    ChunkWaiter<T> GetWaiter<T>(Func<string, T> resultParser, CancellationToken ct);
+    Task Send(Message requestMessage);
+}
+
+[Serializable]
+public class ReplyException : Exception {
+    public ReplyException() { }
+    public ReplyException(string message) : base(message) { }
+    public ReplyException(string message, Exception inner) : base(message, inner) { }
+    protected ReplyException(SerializationInfo info, StreamingContext context) : base(info, context) { }
 }
 
 [JsonObject(MemberSerialization.OptIn, Description = "Describes an item in a Refined Storage system.", MissingMemberHandling = MissingMemberHandling.Ignore)]

MinecraftDiscordBot/IChunkWaiter.cs

@@ -0,0 +1,9 @@
+namespace MinecraftDiscordBot;
+
+public interface IChunkWaiter {
+    bool Finished { get; }
+    int ID { get; }
+    bool IsCancellationRequested { get; }
+    void AddChunk(int chunkId, int totalChunks, string value);
+    void SetUnsuccessful();
+}

MinecraftDiscordBot/ICommandHandler.cs

@@ -0,0 +1,11 @@
+using Discord.WebSocket;
+
+namespace MinecraftDiscordBot;
+
+public interface ICommandHandler {
+    Task HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct);
+}
+
+public interface ICommandHandler<T> {
+    Task<T> HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct);
+}

MinecraftDiscordBot/ItemFilter.cs

@@ -0,0 +1,32 @@
+namespace MinecraftDiscordBot;
+
+public abstract class ItemFilter {
+    public abstract bool Match(Fluid item);
+    public virtual bool MatchItem(Item item) => Match(item);
+
+    public static ItemFilter Parse(string filter)
+        => filter.StartsWith('@')
+            ? new ModNameFilter(filter[1..])
+            : filter.StartsWith('$')
+            ? new TagFilter(filter[1..])
+            : new ItemNameFilter(filter);
+
+    private class ModNameFilter : ItemFilter {
+        private readonly string filter;
+        public ModNameFilter(string filter) => this.filter = filter;
+        public override bool Match(Fluid item) => item.ItemId.ModName.Contains(filter, StringComparison.InvariantCultureIgnoreCase);
+    }
+
+    private class TagFilter : ItemFilter {
+        private readonly string filter;
+        public TagFilter(string filter) => this.filter = filter;
+        public override bool Match(Fluid item)
+            => item.Tags?.Any(tag => tag.Contains(filter, StringComparison.InvariantCultureIgnoreCase)) ?? false;
+    }
+
+    private class ItemNameFilter : ItemFilter {
+        private readonly string filter;
+        public ItemNameFilter(string filter) => this.filter = filter;
+        public override bool Match(Fluid item) => item.DisplayName.Contains(filter, StringComparison.InvariantCultureIgnoreCase);
+    }
+}

MinecraftDiscordBot/Message.cs

@@ -11,7 +11,7 @@ public abstract class Message {
 public class CapabilityMessage : Message {
     public override string Type => "roles";
     [JsonProperty("role", Required = Required.Always)]
-    public string Role { get; set; } = default!;
+    public string[] Role { get; set; } = default!;
 }
 
 public class TextMessage : Message {
@@ -36,10 +36,15 @@ public class ReplyMessage : Message {
     public int AnswerId { get; set; }
     [JsonProperty("result", Required = Required.Always)]
     public string Result { get; set; }
-    [JsonProperty("chunk", Required = Required.Always)]
-    public int Chunk { get; set; }
-    [JsonProperty("total", Required = Required.Always)]
-    public int Total { get; set; }
+    [JsonProperty("chunk", Required = Required.DisallowNull)]
+    public int Chunk { get; set; } = 1;
+    [JsonProperty("total", Required = Required.DisallowNull)]
+    public int Total { get; set; } = 1;
+    /// <summary>
+    /// If at least one packet was received where 
+    /// </summary>
+    [JsonProperty("success", Required = Required.DisallowNull)]
+    public bool Success { get; set; } = true;
     public override string Type => "reply";
 }
 

MinecraftDiscordBot/MinecraftDiscordBot.csproj

@@ -21,6 +21,7 @@
     <PackageReference Include="Fleck" Version="1.2.0" />
     <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.14.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+    <PackageReference Include="OneOf" Version="3.0.205" />
   </ItemGroup>
 
 </Project>

MinecraftDiscordBot/Program.cs

@@ -1,20 +1,22 @@
-using CommandLine;
+using CommandLine;
 using Discord;
 using Discord.Commands;
 using Discord.Rest;
 using Discord.WebSocket;
 using Fleck;
 using Newtonsoft.Json;
+using OneOf;
 using System.Collections.Concurrent;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 
 namespace MinecraftDiscordBot;
 
-public class Program : IDisposable {
+public class Program : IDisposable, ICommandHandler<ResponseType> {
     public const string WebSocketSource = "WebSocket";
     public const string BotSource = "Bot";
     private static readonly object LogLock = new();
+    public const int ChoiceTimeout = 20 * 1000;
     private readonly DiscordSocketClient _client = new(new() {
         LogLevel = LogSeverity.Verbose,
         GatewayIntents = GatewayIntents.AllUnprivileged & ~(GatewayIntents.GuildScheduledEvents | GatewayIntents.GuildInvites)
@@ -25,13 +27,15 @@ public class Program : IDisposable {
     private readonly ConcurrentDictionary<Guid, ConnectedComputer> _connections = new();
     private static readonly char[] WhiteSpace = new char[] { '\t', '\n', ' ', '\r' };
     public ITextChannel[] _channels = Array.Empty<ITextChannel>();
-    private RefinedStorageComputer? _rsSystem = null;
+    private ConnectedComputer? _rsSystem = null;
     private bool disposedValue;
+    public static bool OnlineNotifications => false;
 
-    public RefinedStorageComputer? RsSystem {
+    public ConnectedComputer? Computer {
         get => _rsSystem; set {
             if (_rsSystem != value) {
                 _rsSystem = value;
+                if (OnlineNotifications)
                     _ = Task.Run(() => Broadcast(i => i.SendMessageAsync(value is null
                           ? $"The Refined Storage went offline. Please check the server!"
                           : $"The Refined Storage is back online!")));
@@ -44,6 +48,7 @@ public class Program : IDisposable {
         _config = config;
         _client.Log += LogAsync;
         _client.MessageReceived += (msg) => DiscordMessageReceived(msg);
+        _client.ReactionAdded += DiscordReactionAdded;
         _wssv = new WebSocketServer($"ws://0.0.0.0:{config.Port}") {
             RestartAfterListenError = true
         };
@@ -83,7 +88,7 @@ public class Program : IDisposable {
 
     private async Task<bool> HasValidChannels() {
         if (await GetValidChannels(_whitelistedChannels).ToArrayAsync() is not { Length: > 0 } channels) {
-            await LogError(BotSource, new InvalidOperationException("No valid textchannel was whitelisted!"));
+            await LogErrorAsync(BotSource, new InvalidOperationException("No valid textchannel was whitelisted!"));
             return false;
         }
         _channels = channels;
@@ -100,51 +105,39 @@ public class Program : IDisposable {
         foreach (var channelId in ids) {
             var channel = await _client.GetChannelAsync(channelId);
             if (channel is not ITextChannel textChannel) {
-                if (channel is null) await LogWarning(BotSource, $"Channel with id [{channelId}] does not exist!");
-                else await LogWarning(BotSource, $"Channel is not a text channels and will not be used: {channel.Name} [{channel.Id}]!");
+                if (channel is null) await LogWarningAsync(BotSource, $"Channel with id [{channelId}] does not exist!");
+                else await LogWarningAsync(BotSource, $"Channel is not a text channels and will not be used: {channel.Name} [{channel.Id}]!");
                 continue;
             }
 
             if (textChannel.Guild is RestGuild guild) {
                 await guild.UpdateAsync();
-                await LogInfo(BotSource, $"Whitelisted in channel: {channel.Name} [{channel.Id}] on server {guild.Name} [{guild.Id}]");
+                await LogInfoAsync(BotSource, $"Whitelisted in channel: {channel.Name} [{channel.Id}] on server {guild.Name} [{guild.Id}]");
             } else {
-                await LogWarning(BotSource, $"Whitelisted in channel: {channel.Name} [{channel.Id}] on unknown server!");
+                await LogWarningAsync(BotSource, $"Whitelisted in channel: {channel.Name} [{channel.Id}] on unknown server!");
             }
             yield return textChannel;
         }
     }
 
-    private async Task SocketReceived(IWebSocketConnection socket, string message) {
-        if (JsonConvert.DeserializeObject<CapabilityMessage>(message) is not CapabilityMessage capability) return;
+    private static async Task SocketReceived(IWebSocketConnection socket, string message)
+        => await LogInfoAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Received: {message}");
 
-        try {
-            var pc = capability.Role switch {
-                RefinedStorageComputer.Role => new RefinedStorageComputer(socket),
-                string role => throw new ArgumentException($"Invalid role '{role}'!")
-            };
-            AddComputerSocket(socket, pc);
-            await LogInfo(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Presented capability as {pc.GetType().Name}");
-        } catch (ArgumentException e) {
-            await LogError(WebSocketSource, e);
-        }
-    }
-
-    private void AddComputerSocket(IWebSocketConnection socket, ConnectedComputer pc) {
-        if (pc is RefinedStorageComputer rs) RsSystem = rs;
-    }
+    private void AddComputerSocket(IWebSocketConnection socket, ConnectedComputer pc) => Computer = pc;
 
     private void RemoveComputerSocket(IWebSocketConnection socket) {
-        if (RsSystem?.ConnectionInfo.Id == socket.ConnectionInfo.Id) RsSystem = null;
+        if (Computer is { ConnectionInfo.Id: Guid id } && id == socket.ConnectionInfo.Id) Computer = null;
     }
 
     private async Task SocketClosed(IWebSocketConnection socket) {
         RemoveComputerSocket(socket);
-        await LogInfo(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Client disconnected!");
+        await LogInfoAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Client disconnected!");
     }
 
-    private static async Task SocketOpened(IWebSocketConnection socket)
-        => await LogInfo(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Client connected from {socket.ConnectionInfo.ClientIpAddress}:{socket.ConnectionInfo.ClientPort}!");
+    private async Task SocketOpened(IWebSocketConnection socket) {
+        AddComputerSocket(socket, new(socket));
+        await LogInfoAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Client connected from {socket.ConnectionInfo.ClientIpAddress}:{socket.ConnectionInfo.ClientPort}!");
+    }
 
     private async Task DiscordMessageReceived(SocketMessage arg, int timeout = 10000) {
         if (arg is not SocketUserMessage message) return;
@@ -155,26 +148,61 @@ public class Program : IDisposable {
 
         if (IsCommand(message, out var argPos)) {
             var parameters = message.Content[argPos..].Split(WhiteSpace, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
-            _ = Task.Run(() => HandleCommand(message, parameters, cts.Token));
+            _ = Task.Run(async () => {
+                var response = await HandleCommand(message, parameters, cts.Token);
+                await SendResponse(message, response);
+            });
             return;
         }
 
-        await LogInfo("Discord", $"[{arg.Author.Username}] {arg.Content}");
+        await LogInfoAsync("Discord", $"[{arg.Author.Username}] {arg.Content}");
         // TODO: Relay Message to Chat Receiver   
     }
 
-    private Task HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct)
-        => parameters is { Length: > 0 }
-            ? parameters[0].ToLower() switch {
-                RefinedStorageComputer.Role => HandleRefinedStorageCommand(message, parameters[1..], ct),
-                _ => message.ReplyAsync($"What the fuck do you mean by '{parameters[0]}'?")
-            }
-            : message.ReplyAsync($"You really think an empty command works?");
+    private Task SendResponse(SocketUserMessage message, ResponseType response) => response switch {
+        ResponseType.IChoiceResponse res => HandleChoice(message, res),
+        ResponseType.StringResponse res => message.ReplyAsync(res.Message),
+        _ => message.ReplyAsync($"Whoops, someone forgot to implement '{response.GetType()}' responses?"),
+    };
 
-    private Task HandleRefinedStorageCommand(SocketUserMessage message, string[] parameters, CancellationToken ct)
-        => RsSystem is RefinedStorageComputer rs
-            ? rs.HandleCommand(message, parameters, ct)
-            : message.ReplyAsync("The Refined Storage system is currently unavailable!");
+    private readonly ConcurrentDictionary<ulong, ResponseType.IChoiceResponse> _choiceWait = new();
+
+    private async Task DiscordReactionAdded(Cacheable<IUserMessage, ulong> message, Cacheable<IMessageChannel, ulong> channel, SocketReaction reaction) {
+        var msgObject = await message.GetOrDownloadAsync();
+        if (reaction.UserId == _client.CurrentUser.Id) return;
+        if (!_choiceWait.TryRemove(message.Id, out var choice)) { await LogInfoAsync(BotSource, "Reaction was added to message without choice object!"); return; }
+        await msgObject.DeleteAsync();
+        await LogInfoAsync(BotSource, $"Reaction {reaction.Emote.Name} was added to the choice by {reaction.UserId}!");
+    }
+
+    private async Task HandleChoice(SocketUserMessage message, ResponseType.IChoiceResponse res) {
+        var reply = await message.ReplyAsync($"{res.Query}\n{string.Join("\n", res.Options)}");
+        _choiceWait[reply.Id] = res;
+        var reactions = new Emoji[] { new("0️⃣")/*, new("1️⃣"), new("2️⃣"), new("3️⃣"), new("4️⃣"), new("5️⃣"), new("6️⃣"), new("7️⃣"), new("8️⃣"), new("9️⃣")*/ };
+        await reply.AddReactionsAsync(reactions);
+        _ = Task.Run(async () => {
+            await Task.Delay(ChoiceTimeout);
+            _ = _choiceWait.TryRemove(message.Id, out _);
+            await reply.ModifyAsync(i => i.Content = "You did not choose in time!");
+            await reply.RemoveAllReactionsAsync();
+        });
+    }
+
+    public async Task<ResponseType> HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct) {
+        if (Computer is ICommandHandler<ResponseType> handler)
+            try {
+                return await handler.HandleCommand(message, parameters, ct);
+            } catch (TaskCanceledException) {
+                return ResponseType.AsString("Your request could not be processed in time!");
+            } catch (ReplyException e) {
+                await LogWarningAsync(BotSource, e.Message);
+                return ResponseType.AsString($"Your request failed: {e.Message}");
+            } catch (Exception e) {
+                await LogErrorAsync(BotSource, e);
+                return ResponseType.AsString($"Oopsie doopsie, this should not have happened!");
+            }
+        else return ResponseType.AsString("The Minecraft server is currently unavailable!");
+    }
 
     private bool IsCommand(SocketUserMessage message, out int argPos) {
         argPos = 0;
@@ -183,16 +211,19 @@ public class Program : IDisposable {
     private bool IsChannelWhitelisted(ISocketMessageChannel channel)
         => _whitelistedChannels.Contains(channel.Id);
 
-    public static ConfiguredTaskAwaitable LogInfo(string source, string message) => LogAsync(new(LogSeverity.Info, source, message)).ConfigureAwait(false);
-    public static ConfiguredTaskAwaitable LogWarning(string source, string message) => LogAsync(new(LogSeverity.Warning, source, message)).ConfigureAwait(false);
-    public static ConfiguredTaskAwaitable LogError(string source, Exception exception) => LogAsync(new(LogSeverity.Error, source, exception?.Message, exception)).ConfigureAwait(false);
+    public static ConfiguredTaskAwaitable LogInfoAsync(string source, string message) => LogAsync(new(LogSeverity.Info, source, message)).ConfigureAwait(false);
+    public static ConfiguredTaskAwaitable LogWarningAsync(string source, string message) => LogAsync(new(LogSeverity.Warning, source, message)).ConfigureAwait(false);
+    public static ConfiguredTaskAwaitable LogErrorAsync(string source, Exception exception) => LogAsync(new(LogSeverity.Error, source, exception?.Message, exception)).ConfigureAwait(false);
+    public static void LogInfo(string source, string message) => Log(new(LogSeverity.Info, source, message));
+    public static void LogWarning(string source, string message) => Log(new(LogSeverity.Warning, source, message));
+    public static void LogError(string source, Exception exception) => Log(new(LogSeverity.Error, source, exception?.Message, exception));
 
     private static async Task LogAsync(LogMessage msg) {
         Log(msg);
         await Task.CompletedTask;
     }
 
-    private static void Log(LogMessage msg) {
+    public static void Log(LogMessage msg) {
         lock (LogLock)
             Console.WriteLine(msg.ToString());
     }
@@ -224,3 +255,32 @@ public class Program : IDisposable {
         GC.SuppressFinalize(this);
     }
 }
+
+public abstract class ResponseType {
+    private static string DefaultDisplay<T>(T obj) => obj?.ToString() ?? throw new InvalidProgramException("ToString did not yield anything!");
+    public static ResponseType AsString(string message) => new StringResponse(message);
+    public static ResponseType FromChoice<T>(string query, IEnumerable<T> choice, Func<T, Task> resultHandler, Func<T, string>? display = null) => new ChoiceResponse<T>(query, choice, resultHandler, display ?? DefaultDisplay);
+    public class StringResponse : ResponseType {
+        public StringResponse(string message) => Message = message;
+        public string Message { get; }
+    }
+    public interface IChoiceResponse {
+        IEnumerable<string> Options { get; }
+        string Query { get; }
+        Task HandleResult(int index);
+    }
+    public class ChoiceResponse<T> : ResponseType, IChoiceResponse {
+        private readonly Func<T, Task> _resultHandler;
+        private readonly T[] _options;
+        private readonly Func<T, string> _displayer;
+        public IEnumerable<string> Options => _options.Select(_displayer);
+        public string Query { get; }
+        public Task HandleResult(int index) => _resultHandler(_options[index]);
+        public ChoiceResponse(string query, IEnumerable<T> choice, Func<T, Task> resultHandler, Func<T, string> display) {
+            Query = query;
+            _resultHandler = resultHandler;
+            _options = choice.ToArray();
+            _displayer = display;
+        }
+    }
+}