private async Task OnCommandExecutedAsync(Optional <CommandInfo> optionalCommand, ICommandContext context, IResult result)
        {
            // We have access to the information of the command executed,
            // the context of the command, and the result returned from the
            // execution in this event.

            // command is unspecified when there was a search failure (command not found)
            if (!optionalCommand.IsSpecified)
            {
                await _logService.LogAsync(new LogMessage(LogSeverity.Info, "Command", $"Unknown command: \"{context.Message.Content}\", sent by {context.User} in {context.Display()}"));

                return;
            }
            var command = optionalCommand.Value;

            if (command.Module.Name != Constants.DevelopmentModuleName)
            {
                // Update the command stats
                lock (_cmdStatsLock)
                {
                    var stats = DatabaseConfig.CommandStats;
                    if (stats.ContainsKey(command.Name))
                    {
                        stats[command.Name]++;
                    }
                    else
                    {
                        stats.Add(command.Name, 1);
                    }
                    DatabaseConfig.Update(x => x.CommandStats = stats);
                }
            }

            // the command was successful, we don't care about this result, unless we want to log that a command succeeded.
            if (result.IsSuccess)
            {
                return;
            }

            double ignoreTime = Constants.DefaultIgnoreTime;

            switch (result.Error)
            {
            //case CommandError.UnknownCommand:
            //    await SendEmbedAsync(context.Message, string.Format(LocalizationService.Locate("CommandNotFound", context.Message), GetPrefix(context.Channel)));
            //    break;
            case CommandError.BadArgCount:
            case CommandError.ParseFailed:
                string language = GuildUtils.GetLanguage(context.Channel);
                string prefix   = GuildUtils.GetPrefix(context.Channel);
                await SendEmbedAsync(context.Message, command.ToHelpEmbed(language, prefix), _services);

                break;

            case CommandError.UnmetPrecondition when command.Module.Name != Constants.DevelopmentModuleName:
                ChannelPermissions permissions;
                if (context.Guild == null)
                {
                    permissions = ChannelPermissions.All(context.Channel);
                }
                else
                {
                    var guildUser = await context.Guild.GetCurrentUserAsync().ConfigureAwait(false);

                    permissions = guildUser.GetPermissions((IGuildChannel)context.Channel);
                }

                if (!permissions.Has(Constants.MinimumRequiredPermissions))
                {
                    var builder = new EmbedBuilder()
                                  .WithDescription($"\u26a0 {result.ErrorReason}")
                                  .WithColor(FergunClient.Config.EmbedColor);
                    try
                    {
                        await context.User.SendMessageAsync(embed : builder.Build());
                    }
                    catch (HttpException e) when(e.DiscordCode == 50007)
                    {
                        await _logService.LogAsync(new LogMessage(LogSeverity.Warning, "Command", "Unable to send a DM about the minimum required permissions to the user."));
                    }
                }
                else
                {
                    if (result.ErrorReason.StartsWith("(Cooldown)", StringComparison.OrdinalIgnoreCase))
                    {
                        ignoreTime = Constants.CooldownIgnoreTime;
                    }
                    await SendEmbedAsync(context.Message, $"\u26a0 {GuildUtils.Locate(result.ErrorReason, context.Channel)}", _services);
                }
                break;

            case CommandError.ObjectNotFound:
                // reason: The error reason (User not found., Role not found., etc)
                string reason = result.ErrorReason;
                // Delete the last char (.)
                reason = reason.Substring(0, result.ErrorReason.Length - 1);
                // Convert to title case (User Not Found)
                reason = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(reason);
                // Remove spaces (UserNotFound)
                reason = reason.Replace(" ", string.Empty, StringComparison.OrdinalIgnoreCase);
                // Locate the string to the current language of the guild
                reason = GuildUtils.Locate(reason, context.Channel);
                await SendEmbedAsync(context.Message, $"\u26a0 {reason}", _services);

                break;

            case CommandError.MultipleMatches:
                await SendEmbedAsync(context.Message, $"\u26a0 {GuildUtils.Locate("MultipleMatches", context.Channel)}", _services);

                break;

            case CommandError.Unsuccessful:
                await SendEmbedAsync(context.Message, $"\u26a0 {result.ErrorReason}".Truncate(EmbedBuilder.MaxDescriptionLength), _services);

                break;

            case CommandError.Exception when result is ExecuteResult execResult:
                var exception = execResult.Exception;

                if (exception is HttpException httpException && httpException.HttpCode >= HttpStatusCode.InternalServerError)
                {
                    await Task.Delay(2000);

                    var builder = new EmbedBuilder()
                                  .WithTitle(GuildUtils.Locate("DiscordServerError", context.Channel))
                                  .WithDescription($"\u26a0 {GuildUtils.Locate("DiscordServerErrorInfo", context.Channel)}")
                                  .AddField(GuildUtils.Locate("ErrorDetails", context.Channel),
                                            Format.Code($"Code: {(int)httpException.HttpCode}, Reason: {httpException.Reason}", "md"))
                                  .WithColor(FergunClient.Config.EmbedColor);

                    try
                    {
                        await SendEmbedAsync(context.Message, builder.Build(), _services);
                    }
                    catch (HttpException) { }
                    break;
                }

                var builder2 = new EmbedBuilder()
                               .WithTitle($"\u274c {GuildUtils.Locate("FailedExecution", context.Channel)} {Format.Code(command.Name)}")
                               .AddField(GuildUtils.Locate("ErrorType", context.Channel), Format.Code(exception.GetType().Name, "cs"))
                               .AddField(GuildUtils.Locate("ErrorMessage", context.Channel), Format.Code(exception.Message, "cs"))
                               .WithColor(FergunClient.Config.EmbedColor);

                var owner = (await context.Client.GetApplicationInfoAsync()).Owner;

                if (context.User.Id != owner.Id)
                {
                    builder2.WithFooter(GuildUtils.Locate("ErrorSentToOwner", context.Channel));
                }

                await SendEmbedAsync(context.Message, builder2.Build(), _services);

                if (context.User.Id == owner.Id)
                {
                    break;
                }
                // if the user that executed the command isn't the bot owner, send the full stack trace to the errors channel

                var channel = await context.Client.GetChannelAsync(FergunClient.Config.LogChannel);

                if (!(channel is IMessageChannel messageChannel))
                {
                    await _logService.LogAsync(new LogMessage(LogSeverity.Warning, "Command", $"Invalid log channel Id ({FergunClient.Config.LogChannel}). Not possible to send the embed with the error info."));

                    break;
                }

                var builder3 = new EmbedBuilder()
                               .WithTitle($"\u274c Failed to execute {Format.Code(command.Name)} in {context.Display()}".Truncate(EmbedBuilder.MaxTitleLength))
                               .AddField(GuildUtils.Locate("ErrorType", messageChannel), Format.Code(exception.GetType().Name, "cs"))
                               .AddField(GuildUtils.Locate("ErrorMessage", messageChannel), Format.Code(exception.ToString().Truncate(EmbedFieldBuilder.MaxFieldValueLength - 10), "cs"))
                               .AddField("Jump url", context.Message.GetJumpUrl())
                               .AddField("Command", context.Message.Content.Truncate(EmbedFieldBuilder.MaxFieldValueLength))
                               .WithColor(FergunClient.Config.EmbedColor);

                try
                {
                    await messageChannel.SendMessageAsync(embed : builder3.Build());
                }
                catch (HttpException e)
                {
                    await _logService.LogAsync(new LogMessage(LogSeverity.Warning, "Command", "Error while sending the embed in the log channel", e));
                }
                break;
            }

            _ = IgnoreUserAsync(context.User.Id, TimeSpan.FromSeconds(ignoreTime));
            await _logService.LogAsync(new LogMessage(LogSeverity.Info, "Command", $"Failed to execute \"{command.Name}\" for {context.User} in {context.Display()}, with error type: {result.Error} and reason: {result.ErrorReason}"));
        }