Apply official naming guidelines to Octobot (#306)

1. The root namespace was changed from `Octobot` to
`TeamOctolings.Octobot`:
> DO prefix namespace names with a company name to prevent namespaces
from different companies from having the same name.
2. `Octobot.cs` was renamed to `Program.cs`:
> DO NOT use the same name for a namespace and a type in that namespace.
3. `IOption`, `Option` were renamed to `IGuildOption` and `GuildOption`
respectively:
> DO NOT introduce generic type names such as Element, Node, Log, and
Message.
4. `Utility` was moved out of the `Services` namespace. It didn't belong
there anyway
5. `Program` static fields were moved to `Utility`
6. Localisation files were moved back to the project source files. Looks
like this fixed `Message.Designer.cs` code generation

---------

Signed-off-by: Octol1ttle <l1ttleofficial@outlook.com>

TeamOctolings.Octobot/Responders/GuildLoadedResponder.cs

@@ -0,0 +1,125 @@
+using JetBrains.Annotations;
+using Microsoft.Extensions.Logging;
+using Remora.Discord.API.Abstractions.Gateway.Events;
+using Remora.Discord.API.Abstractions.Objects;
+using Remora.Discord.API.Abstractions.Rest;
+using Remora.Discord.API.Gateway.Events;
+using Remora.Discord.API.Objects;
+using Remora.Discord.Extensions.Embeds;
+using Remora.Discord.Gateway.Responders;
+using Remora.Results;
+using TeamOctolings.Octobot.Data;
+using TeamOctolings.Octobot.Extensions;
+using TeamOctolings.Octobot.Services;
+
+namespace TeamOctolings.Octobot.Responders;
+
+/// <summary>
+///     Handles sending a <see cref="Ready" /> message to a guild that has just initialized if that guild
+///     has <see cref="GuildSettings.ReceiveStartupMessages" /> enabled
+/// </summary>
+[UsedImplicitly]
+public class GuildLoadedResponder : IResponder<IGuildCreate>
+{
+    private readonly IDiscordRestChannelAPI _channelApi;
+    private readonly GuildDataService _guildData;
+    private readonly ILogger<GuildLoadedResponder> _logger;
+    private readonly IDiscordRestUserAPI _userApi;
+    private readonly Utility _utility;
+
+    public GuildLoadedResponder(
+        IDiscordRestChannelAPI channelApi, GuildDataService guildData, ILogger<GuildLoadedResponder> logger,
+        IDiscordRestUserAPI userApi, Utility utility)
+    {
+        _channelApi = channelApi;
+        _guildData = guildData;
+        _logger = logger;
+        _userApi = userApi;
+        _utility = utility;
+    }
+
+    public async Task<Result> RespondAsync(IGuildCreate gatewayEvent, CancellationToken ct = default)
+    {
+        if (!gatewayEvent.Guild.IsT0) // Guild is not IAvailableGuild
+        {
+            return Result.Success;
+        }
+
+        var guild = gatewayEvent.Guild.AsT0;
+
+        var data = await _guildData.GetData(guild.ID, ct);
+        var cfg = data.Settings;
+        foreach (var member in guild.Members.Where(m => m.User.HasValue))
+        {
+            data.GetOrCreateMemberData(member.User.Value.ID);
+        }
+
+        var botResult = await _userApi.GetCurrentUserAsync(ct);
+        if (!botResult.IsDefined(out var bot))
+        {
+            return ResultExtensions.FromError(botResult);
+        }
+
+        if (data.DataLoadFailed)
+        {
+            return await SendDataLoadFailed(guild, data, bot, ct);
+        }
+
+        var ownerResult = await _userApi.GetUserAsync(guild.OwnerID, ct);
+        if (!ownerResult.IsDefined(out var owner))
+        {
+            return ResultExtensions.FromError(ownerResult);
+        }
+
+        _logger.LogInformation("Loaded guild \"{Name}\" ({ID}) owned by {Owner} ({OwnerID}) with {MemberCount} members",
+            guild.Name, guild.ID, owner.GetTag(), owner.ID, guild.MemberCount);
+
+        if (GuildSettings.PrivateFeedbackChannel.Get(cfg).Empty()
+            || !GuildSettings.ReceiveStartupMessages.Get(cfg))
+        {
+            return Result.Success;
+        }
+
+        Messages.Culture = GuildSettings.Language.Get(cfg);
+        var i = Random.Shared.Next(1, 4);
+
+        var embed = new EmbedBuilder().WithSmallTitle(bot.GetTag(), bot)
+            .WithTitle($"Generic{i}".Localized())
+            .WithDescription(Messages.Ready)
+            .WithCurrentTimestamp()
+            .WithColour(ColorsList.Blue)
+            .Build();
+
+        return await _channelApi.CreateMessageWithEmbedResultAsync(
+            GuildSettings.PrivateFeedbackChannel.Get(cfg), embedResult: embed, ct: ct);
+    }
+
+    private async Task<Result> SendDataLoadFailed(IGuild guild, GuildData data, IUser bot, CancellationToken ct)
+    {
+        var channelResult = await _utility.GetEmergencyFeedbackChannel(guild, data, ct);
+        if (!channelResult.IsDefined(out var channel))
+        {
+            return ResultExtensions.FromError(channelResult);
+        }
+
+        var errorEmbed = new EmbedBuilder()
+            .WithSmallTitle(Messages.DataLoadFailedTitle, bot)
+            .WithDescription(Messages.DataLoadFailedDescription)
+            .WithFooter(Messages.ContactDevelopers)
+            .WithColour(ColorsList.Red)
+            .Build();
+
+        var issuesButton = new ButtonComponent(
+            ButtonComponentStyle.Link,
+            BuildInfo.IsDirty
+                ? Messages.ButtonDirty
+                : Messages.ButtonReportIssue,
+            new PartialEmoji(Name: "\u26a0\ufe0f"), // 'WARNING SIGN' (U+26A0)
+            URL: BuildInfo.IssuesUrl,
+            IsDisabled: BuildInfo.IsDirty
+        );
+
+        return await _channelApi.CreateMessageWithEmbedResultAsync(channel, embedResult: errorEmbed,
+            components: new[] { new ActionRowComponent(new[] { issuesButton }) }, ct: ct);
+    }
+}

TeamOctolings.Octobot/Responders/GuildMemberJoinedResponder.cs

@@ -0,0 +1,106 @@
+using System.Text.Json.Nodes;
+using JetBrains.Annotations;
+using Remora.Discord.API.Abstractions.Gateway.Events;
+using Remora.Discord.API.Abstractions.Rest;
+using Remora.Discord.Extensions.Embeds;
+using Remora.Discord.Gateway.Responders;
+using Remora.Rest.Core;
+using Remora.Results;
+using TeamOctolings.Octobot.Data;
+using TeamOctolings.Octobot.Extensions;
+using TeamOctolings.Octobot.Services;
+
+namespace TeamOctolings.Octobot.Responders;
+
+/// <summary>
+///     Handles sending a guild's <see cref="GuildSettings.WelcomeMessage" /> if one is set.
+///     If <see cref="GuildSettings.ReturnRolesOnRejoin" /> is enabled, roles will be returned.
+/// </summary>
+/// <seealso cref="GuildSettings.WelcomeMessage" />
+[UsedImplicitly]
+public class GuildMemberJoinedResponder : IResponder<IGuildMemberAdd>
+{
+    private readonly IDiscordRestChannelAPI _channelApi;
+    private readonly IDiscordRestGuildAPI _guildApi;
+    private readonly GuildDataService _guildData;
+
+    public GuildMemberJoinedResponder(
+        IDiscordRestChannelAPI channelApi, GuildDataService guildData, IDiscordRestGuildAPI guildApi)
+    {
+        _channelApi = channelApi;
+        _guildData = guildData;
+        _guildApi = guildApi;
+    }
+
+    public async Task<Result> RespondAsync(IGuildMemberAdd gatewayEvent, CancellationToken ct = default)
+    {
+        if (!gatewayEvent.User.IsDefined(out var user))
+        {
+            return new ArgumentNullError(nameof(gatewayEvent.User));
+        }
+
+        var data = await _guildData.GetData(gatewayEvent.GuildID, ct);
+        var cfg = data.Settings;
+        var memberData = data.GetOrCreateMemberData(user.ID);
+
+        memberData.Kicked = false;
+
+        var returnRolesResult = await TryReturnRolesAsync(cfg, memberData, gatewayEvent.GuildID, user.ID, ct);
+        if (!returnRolesResult.IsSuccess)
+        {
+            return ResultExtensions.FromError(returnRolesResult);
+        }
+
+        if (GuildSettings.WelcomeMessagesChannel.Get(cfg).Empty()
+            || GuildSettings.WelcomeMessage.Get(cfg) is "off" or "disable" or "disabled")
+        {
+            return Result.Success;
+        }
+
+        Messages.Culture = GuildSettings.Language.Get(cfg);
+        var welcomeMessage = GuildSettings.WelcomeMessage.Get(cfg) is "default" or "reset"
+            ? Messages.DefaultWelcomeMessage
+            : GuildSettings.WelcomeMessage.Get(cfg);
+
+        var guildResult = await _guildApi.GetGuildAsync(gatewayEvent.GuildID, ct: ct);
+        if (!guildResult.IsDefined(out var guild))
+        {
+            return ResultExtensions.FromError(guildResult);
+        }
+
+        var embed = new EmbedBuilder()
+            .WithSmallTitle(string.Format(welcomeMessage, user.GetTag(), guild.Name), user)
+            .WithGuildFooter(guild)
+            .WithTimestamp(gatewayEvent.JoinedAt)
+            .WithColour(ColorsList.Green)
+            .Build();
+
+        return await _channelApi.CreateMessageWithEmbedResultAsync(
+            GuildSettings.WelcomeMessagesChannel.Get(cfg), embedResult: embed,
+            allowedMentions: Utility.NoMentions, ct: ct);
+    }
+
+    private async Task<Result> TryReturnRolesAsync(
+        JsonNode cfg, MemberData memberData, Snowflake guildId, Snowflake userId, CancellationToken ct)
+    {
+        if (!GuildSettings.ReturnRolesOnRejoin.Get(cfg))
+        {
+            return Result.Success;
+        }
+
+        var assignRoles = new List<Snowflake>();
+
+        if (memberData.MutedUntil is null || !GuildSettings.RemoveRolesOnMute.Get(cfg))
+        {
+            assignRoles.AddRange(memberData.Roles.ConvertAll(r => r.ToSnowflake()));
+        }
+
+        if (memberData.MutedUntil is not null)
+        {
+            assignRoles.Add(GuildSettings.MuteRole.Get(cfg));
+        }
+
+        return await _guildApi.ModifyGuildMemberAsync(
+            guildId, userId, roles: assignRoles, ct: ct);
+    }
+}

TeamOctolings.Octobot/Responders/GuildMemberLeftResponder.cs

@@ -0,0 +1,72 @@
+using JetBrains.Annotations;
+using Remora.Discord.API.Abstractions.Gateway.Events;
+using Remora.Discord.API.Abstractions.Rest;
+using Remora.Discord.Extensions.Embeds;
+using Remora.Discord.Gateway.Responders;
+using Remora.Results;
+using TeamOctolings.Octobot.Data;
+using TeamOctolings.Octobot.Extensions;
+using TeamOctolings.Octobot.Services;
+
+namespace TeamOctolings.Octobot.Responders;
+
+/// <summary>
+///     Handles sending a guild's <see cref="GuildSettings.LeaveMessage" /> if one is set.
+/// </summary>
+/// <seealso cref="GuildSettings.LeaveMessage" />
+[UsedImplicitly]
+public class GuildMemberLeftResponder : IResponder<IGuildMemberRemove>
+{
+    private readonly IDiscordRestChannelAPI _channelApi;
+    private readonly IDiscordRestGuildAPI _guildApi;
+    private readonly GuildDataService _guildData;
+
+    public GuildMemberLeftResponder(
+        IDiscordRestChannelAPI channelApi, GuildDataService guildData, IDiscordRestGuildAPI guildApi)
+    {
+        _channelApi = channelApi;
+        _guildData = guildData;
+        _guildApi = guildApi;
+    }
+
+    public async Task<Result> RespondAsync(IGuildMemberRemove gatewayEvent, CancellationToken ct = default)
+    {
+        var user = gatewayEvent.User;
+        var data = await _guildData.GetData(gatewayEvent.GuildID, ct);
+        var cfg = data.Settings;
+
+        var memberData = data.GetOrCreateMemberData(user.ID);
+        if (memberData.BannedUntil is not null || memberData.Kicked)
+        {
+            return Result.Success;
+        }
+
+        if (GuildSettings.WelcomeMessagesChannel.Get(cfg).Empty()
+            || GuildSettings.LeaveMessage.Get(cfg) is "off" or "disable" or "disabled")
+        {
+            return Result.Success;
+        }
+
+        Messages.Culture = GuildSettings.Language.Get(cfg);
+        var leaveMessage = GuildSettings.LeaveMessage.Get(cfg) is "default" or "reset"
+            ? Messages.DefaultLeaveMessage
+            : GuildSettings.LeaveMessage.Get(cfg);
+
+        var guildResult = await _guildApi.GetGuildAsync(gatewayEvent.GuildID, ct: ct);
+        if (!guildResult.IsDefined(out var guild))
+        {
+            return ResultExtensions.FromError(guildResult);
+        }
+
+        var embed = new EmbedBuilder()
+            .WithSmallTitle(string.Format(leaveMessage, user.GetTag(), guild.Name), user)
+            .WithGuildFooter(guild)
+            .WithTimestamp(DateTimeOffset.UtcNow)
+            .WithColour(ColorsList.Black)
+            .Build();
+
+        return await _channelApi.CreateMessageWithEmbedResultAsync(
+            GuildSettings.WelcomeMessagesChannel.Get(cfg), embedResult: embed,
+            allowedMentions: Utility.NoMentions, ct: ct);
+    }
+}

TeamOctolings.Octobot/Responders/GuildUnloadedResponder.cs

@@ -0,0 +1,38 @@
+using JetBrains.Annotations;
+using Microsoft.Extensions.Logging;
+using Remora.Discord.API.Abstractions.Gateway.Events;
+using Remora.Discord.Gateway.Responders;
+using Remora.Results;
+using TeamOctolings.Octobot.Data;
+using TeamOctolings.Octobot.Services;
+
+namespace TeamOctolings.Octobot.Responders;
+
+/// <summary>
+///     Handles removing guild ID from <see cref="GuildData" /> if the guild becomes unavailable.
+/// </summary>
+[UsedImplicitly]
+public class GuildUnloadedResponder : IResponder<IGuildDelete>
+{
+    private readonly GuildDataService _guildData;
+    private readonly ILogger<GuildUnloadedResponder> _logger;
+
+    public GuildUnloadedResponder(
+        GuildDataService guildData, ILogger<GuildUnloadedResponder> logger)
+    {
+        _guildData = guildData;
+        _logger = logger;
+    }
+
+    public Task<Result> RespondAsync(IGuildDelete gatewayEvent, CancellationToken ct = default)
+    {
+        var guildId = gatewayEvent.ID;
+        var isDataRemoved = _guildData.UnloadGuildData(guildId);
+        if (isDataRemoved)
+        {
+            _logger.LogInformation("Unloaded guild {GuildId}", guildId);
+        }
+
+        return Task.FromResult(Result.Success);
+    }
+}

TeamOctolings.Octobot/Responders/MessageDeletedResponder.cs

@@ -0,0 +1,107 @@
+using System.Text;
+using JetBrains.Annotations;
+using Remora.Discord.API.Abstractions.Gateway.Events;
+using Remora.Discord.API.Abstractions.Objects;
+using Remora.Discord.API.Abstractions.Rest;
+using Remora.Discord.Extensions.Embeds;
+using Remora.Discord.Extensions.Formatting;
+using Remora.Discord.Gateway.Responders;
+using Remora.Results;
+using TeamOctolings.Octobot.Data;
+using TeamOctolings.Octobot.Extensions;
+using TeamOctolings.Octobot.Services;
+
+namespace TeamOctolings.Octobot.Responders;
+
+/// <summary>
+///     Handles logging the contents of a deleted message and the user who deleted the message
+///     to a guild's <see cref="GuildSettings.PrivateFeedbackChannel" /> if one is set.
+/// </summary>
+[UsedImplicitly]
+public class MessageDeletedResponder : IResponder<IMessageDelete>
+{
+    private readonly IDiscordRestAuditLogAPI _auditLogApi;
+    private readonly IDiscordRestChannelAPI _channelApi;
+    private readonly GuildDataService _guildData;
+    private readonly IDiscordRestUserAPI _userApi;
+
+    public MessageDeletedResponder(
+        IDiscordRestAuditLogAPI auditLogApi, IDiscordRestChannelAPI channelApi,
+        GuildDataService guildData, IDiscordRestUserAPI userApi)
+    {
+        _auditLogApi = auditLogApi;
+        _channelApi = channelApi;
+        _guildData = guildData;
+        _userApi = userApi;
+    }
+
+    public async Task<Result> RespondAsync(IMessageDelete gatewayEvent, CancellationToken ct = default)
+    {
+        if (!gatewayEvent.GuildID.IsDefined(out var guildId))
+        {
+            return Result.Success;
+        }
+
+        var cfg = await _guildData.GetSettings(guildId, ct);
+        if (GuildSettings.PrivateFeedbackChannel.Get(cfg).Empty())
+        {
+            return Result.Success;
+        }
+
+        var messageResult = await _channelApi.GetChannelMessageAsync(gatewayEvent.ChannelID, gatewayEvent.ID, ct);
+        if (!messageResult.IsDefined(out var message))
+        {
+            return ResultExtensions.FromError(messageResult);
+        }
+
+        if (string.IsNullOrWhiteSpace(message.Content))
+        {
+            return Result.Success;
+        }
+
+        var auditLogResult = await _auditLogApi.GetGuildAuditLogAsync(
+            guildId, actionType: AuditLogEvent.MessageDelete, limit: 1, ct: ct);
+        if (!auditLogResult.IsDefined(out var auditLogPage))
+        {
+            return ResultExtensions.FromError(auditLogResult);
+        }
+
+        var auditLog = auditLogPage.AuditLogEntries.Single();
+
+        var deleterResult = Result<IUser>.FromSuccess(message.Author);
+        if (auditLog.UserID is not null
+            && auditLog.Options.Value.ChannelID == gatewayEvent.ChannelID
+            && DateTimeOffset.UtcNow.Subtract(auditLog.ID.Timestamp).TotalSeconds <= 2)
+        {
+            deleterResult = await _userApi.GetUserAsync(auditLog.UserID.Value, ct);
+        }
+
+        if (!deleterResult.IsDefined(out var deleter))
+        {
+            return ResultExtensions.FromError(deleterResult);
+        }
+
+        Messages.Culture = GuildSettings.Language.Get(cfg);
+
+        var builder = new StringBuilder()
+            .AppendLine(message.Content.InBlockCode())
+            .AppendLine(
+                string.Format(Messages.DescriptionActionJumpToChannel, Mention.Channel(gatewayEvent.ChannelID))
+            );
+
+        var embed = new EmbedBuilder()
+            .WithSmallTitle(
+                string.Format(
+                    Messages.CachedMessageDeleted,
+                    message.Author.GetTag()), message.Author)
+            .WithDescription(builder.ToString())
+            .WithActionFooter(deleter)
+            .WithTimestamp(message.Timestamp)
+            .WithColour(ColorsList.Red)
+            .Build();
+
+        return await _channelApi.CreateMessageWithEmbedResultAsync(
+            GuildSettings.PrivateFeedbackChannel.Get(cfg), embedResult: embed,
+            allowedMentions: Utility.NoMentions, ct: ct);
+    }
+}

TeamOctolings.Octobot/Responders/MessageEditedResponder.cs

@@ -0,0 +1,109 @@
+using System.Text;
+using DiffPlex.DiffBuilder;
+using JetBrains.Annotations;
+using Remora.Discord.API.Abstractions.Gateway.Events;
+using Remora.Discord.API.Abstractions.Objects;
+using Remora.Discord.API.Abstractions.Rest;
+using Remora.Discord.Caching;
+using Remora.Discord.Caching.Services;
+using Remora.Discord.Extensions.Embeds;
+using Remora.Discord.Gateway.Responders;
+using Remora.Results;
+using TeamOctolings.Octobot.Data;
+using TeamOctolings.Octobot.Extensions;
+using TeamOctolings.Octobot.Services;
+
+namespace TeamOctolings.Octobot.Responders;
+
+/// <summary>
+///     Handles logging the difference between an edited message's old and new content
+///     to a guild's <see cref="GuildSettings.PrivateFeedbackChannel" /> if one is set.
+/// </summary>
+[UsedImplicitly]
+public class MessageEditedResponder : IResponder<IMessageUpdate>
+{
+    private readonly CacheService _cacheService;
+    private readonly IDiscordRestChannelAPI _channelApi;
+    private readonly GuildDataService _guildData;
+
+    public MessageEditedResponder(
+        CacheService cacheService, IDiscordRestChannelAPI channelApi, GuildDataService guildData)
+    {
+        _cacheService = cacheService;
+        _channelApi = channelApi;
+        _guildData = guildData;
+    }
+
+    public async Task<Result> RespondAsync(IMessageUpdate gatewayEvent, CancellationToken ct = default)
+    {
+        if (!gatewayEvent.ID.IsDefined(out var messageId))
+        {
+            return new ArgumentNullError(nameof(gatewayEvent.ID));
+        }
+
+        if (!gatewayEvent.ChannelID.IsDefined(out var channelId))
+        {
+            return new ArgumentNullError(nameof(gatewayEvent.ChannelID));
+        }
+
+        if (!gatewayEvent.GuildID.IsDefined(out var guildId)
+            || !gatewayEvent.Author.IsDefined(out var author)
+            || !gatewayEvent.EditedTimestamp.IsDefined(out var timestamp)
+            || !gatewayEvent.Content.IsDefined(out var newContent))
+        {
+            return Result.Success;
+        }
+
+        var cfg = await _guildData.GetSettings(guildId, ct);
+        if (author.IsBot.OrDefault(false) || GuildSettings.PrivateFeedbackChannel.Get(cfg).Empty())
+        {
+            return Result.Success;
+        }
+
+        var cacheKey = new KeyHelpers.MessageCacheKey(channelId, messageId);
+        var messageResult = await _cacheService.TryGetValueAsync<IMessage>(
+            cacheKey, ct);
+        if (!messageResult.IsDefined(out var message))
+        {
+            _ = _channelApi.GetChannelMessageAsync(channelId, messageId, ct);
+            return Result.Success;
+        }
+
+        if (message.Content == newContent)
+        {
+            return Result.Success;
+        }
+
+        // Custom event responders are called earlier than responders responsible for message caching
+        // This means that subsequent edit logs may contain the wrong content
+        // We can work around this by evicting the message from the cache
+        await _cacheService.EvictAsync<IMessage>(cacheKey, ct);
+        // However, since we evicted the message, subsequent edits won't have a cached instance to work with
+        // Getting the message will put it back in the cache, resolving all issues
+        // We don't need to await this since the result is not needed
+        // NOTE: Because this is not awaited, there may be a race condition depending on how fast clients are able to edit their messages
+        // NOTE: Awaiting this might not even solve this if the same responder is called asynchronously
+        _ = _channelApi.GetChannelMessageAsync(channelId, messageId, ct);
+
+        var diff = InlineDiffBuilder.Diff(message.Content, newContent);
+
+        Messages.Culture = GuildSettings.Language.Get(cfg);
+
+        var builder = new StringBuilder()
+            .AppendLine(diff.AsMarkdown())
+            .AppendLine(string.Format(Messages.DescriptionActionJumpToMessage,
+                $"https://discord.com/channels/{guildId}/{channelId}/{messageId}")
+            );
+
+        var embed = new EmbedBuilder()
+            .WithSmallTitle(string.Format(Messages.CachedMessageEdited, message.Author.GetTag()), message.Author)
+            .WithDescription(builder.ToString())
+            .WithTimestamp(timestamp.Value)
+            .WithColour(ColorsList.Yellow)
+            .Build();
+
+        return await _channelApi.CreateMessageWithEmbedResultAsync(
+            GuildSettings.PrivateFeedbackChannel.Get(cfg), embedResult: embed,
+            allowedMentions: Utility.NoMentions, ct: ct);
+    }
+}

TeamOctolings.Octobot/Responders/MessageReceivedResponder.cs

@@ -0,0 +1,39 @@
+using JetBrains.Annotations;
+using Remora.Discord.API.Abstractions.Gateway.Events;
+using Remora.Discord.API.Abstractions.Rest;
+using Remora.Discord.Gateway.Responders;
+using Remora.Rest.Core;
+using Remora.Results;
+
+namespace TeamOctolings.Octobot.Responders;
+
+/// <summary>
+///     Handles sending replies to easter egg messages.
+/// </summary>
+[UsedImplicitly]
+public class MessageCreateResponder : IResponder<IMessageCreate>
+{
+    private readonly IDiscordRestChannelAPI _channelApi;
+
+    public MessageCreateResponder(IDiscordRestChannelAPI channelApi)
+    {
+        _channelApi = channelApi;
+    }
+
+    public Task<Result> RespondAsync(IMessageCreate gatewayEvent, CancellationToken ct = default)
+    {
+        _ = _channelApi.CreateMessageAsync(
+            gatewayEvent.ChannelID, ct: ct, content: gatewayEvent.Content.ToLowerInvariant() switch
+            {
+                "whoami" => "`nobody`",
+                "сука !!" => "`root`",
+                "воооо" => "`removing /...`",
+                "пон" => "https://i.ibb.co/Kw6QVcw/parry.jpg",
+                "++++" => "#",
+                "осу" => "https://github.com/ppy/osu",
+                "лан" => "https://i.ibb.co/VYH2QLc/lan.jpg",
+                _ => default(Optional<string>)
+            });
+        return Task.FromResult(Result.Success);
+    }
+}