tfjm-discord-bot/src/cogs/misc.py

import ast
import asyncio
import datetime
import io
import itertools
import operator as op
import random
import re
import traceback
import urllib
from collections import Counter, defaultdict
from dataclasses import dataclass, field
from functools import partial
import math
from operator import attrgetter, itemgetter
from time import time
from typing import List, Set, Union

import aiohttp
import discord
import yaml
from discord import Guild, Member
from discord.ext import commands
from discord.ext.commands import (BadArgument, Cog, command, Command, CommandError, Context, Group, group, is_owner,
                                  MemberConverter, RoleConverter)
from discord.utils import get

from src.constants import *
from src.core import CustomBot
from src.errors import TfjmError
from src.utils import has_role, send_and_bin, start_time

# supported operators
OPS = {
    ast.Add: op.add, ast.Sub: op.sub, ast.Mult: op.mul,
    ast.FloorDiv: op.floordiv, ast.Mod: op.mod,
    ast.Div: op.truediv, ast.Pow: op.pow, ast.BitXor: op.xor,
    ast.USub: op.neg, "abs": abs, "π": math.pi, "τ": math.tau,
    "i": 1j,
}

for name in dir(math):
    if not name.startswith("_"):
        OPS[name] = getattr(math, name)

@dataclass
class Joke(yaml.YAMLObject):
    yaml_tag = "Joke"
    yaml_dumper = yaml.SafeDumper
    yaml_loader = yaml.SafeLoader
    joke: str
    joker: int
    likes: Set[int] = field(default_factory=set)
    dislikes: Set[int] = field(default_factory=set)
    file: str = None


HUG_RE = re.compile(r"^(?P<hugger>\d+) -> (?P<hugged>\d+) \| (?P<text>.*)$")


class Hug:
    def __init__(self, hugger, hugged, text):
        self.hugger = hugger
        self.hugged = hugged
        self.text = text

    @classmethod
    def from_str(cls, line: str):
        match = HUG_RE.match(line)
        if not match:
            raise ValueError(f"'{line}' is not a valid hug format.")
        hugger = int(match.group("hugger"))
        hugged = int(match.group("hugged"))
        text = match.group("text")

        return cls(hugger, hugged, text)

    def __repr__(self):
        return f"{self.hugger} -> {self.hugged} | {self.text}"


class MiscCog(Cog, name="Divers"):
    def __init__(self, bot: CustomBot):
        self.bot = bot
        self.show_hidden = False
        self.verify_checks = True
        self.computing = False
        self.hugs = self.get_hugs()

    @command(
        name="choose",
        usage='choix1 choix2 "choix 3"...',
        aliases=["choice", "choix", "ch"],
    )
    async def choose(self, ctx: Context, *args):
        """
        Choisit une option parmi tous les arguments.

        Pour les options qui contiennent une espace,
        il suffit de mettre des guillemets (`"`) autour.
        """

        choice = random.choice(args)
        msg = await ctx.send(f"J'ai choisi... **{choice}**")
        await self.bot.wait_for_bin(ctx.author, msg),

    @command(name="status")
    @commands.has_role(Role.CNO)
    async def status_cmd(self, ctx: Context):
        """(cno) Affiche des informations à propos du serveur."""
        guild: Guild = ctx.guild
        embed = discord.Embed(title="État du serveur", color=EMBED_COLOR)
        benevoles = [g for g in guild.members if has_role(g, Role.BENEVOLE)]
        participants = [g for g in guild.members if has_role(g, Role.PARTICIPANT)]
        no_role = [g for g in guild.members if g.top_role == guild.default_role]
        uptime = datetime.timedelta(seconds=round(time() - start_time()))
        text = len(guild.text_channels)
        vocal = len(guild.voice_channels)
        infos = {
            "Bénévoles": len(benevoles),
            "Participants": len(participants),
            "Sans rôle": len(no_role),
            "Total": len(guild.members),
            "Salons texte": text,
            "Salons vocaux": vocal,
            "Bot uptime": uptime,
        }

        width = max(map(len, infos))
        txt = "\n".join(
            f"`{key.rjust(width)}`: {value}" for key, value in infos.items()
        )
        embed.add_field(name="Stats", value=txt)

        await ctx.send(embed=embed)

    @command(hidden=True)
    async def fractal(self, ctx: Context):

        if self.computing:
            return await ctx.send("Il y a déjà une fractale en cours de calcul...")

        try:
            self.computing = True

            await ctx.message.add_reaction(Emoji.CHECK)
            msg: discord.Message = ctx.message
            seed = msg.content[len("!fractal ") :]
            seed = seed or str(random.randint(0, 1_000_000_000))
            async with aiohttp.ClientSession() as session:
                async with session.get(
                    FRACTAL_URL.format(seed=urllib.parse.quote(seed)), timeout=120
                ) as resp:
                    if resp.status != 200:
                        return await ctx.send(
                            "Il y a un problème pour calculer/télécharger l'image..."
                        )
                    data = io.BytesIO(await resp.read())
                    await ctx.send(
                        f"Seed: {seed}", file=discord.File(data, f"{seed}.png")
                    )
        finally:
            self.computing = False

    @command(hidden=True, aliases=["bang", "pan"])
    async def pew(self, ctx):
        await ctx.send("Tu t'es raté ! Kwaaack :duck:")

    @command(aliases=["pong"])
    async def ping(self, ctx):
        """Affiche la latence avec le bot."""
        msg: discord.Message = ctx.message
        ping = msg.created_at.timestamp()
        msg: discord.Message = await ctx.send("Pong !")
        pong = time()

        # 7200 is because we are UTC+2
        delta = pong - ping - 7200

        await msg.edit(content=f"Pong ! Ça a pris {int(1000 * (delta))}ms")

    @command(name="fan", aliases=["join", "adhere"], hidden=True)
    async def fan_club_cmd(self, ctx: Context, who: Member):
        """Permet de rejoindre un fan club existant."""
        role_id = FAN_CLUBS.get(who.id, None)
        role = get(ctx.guild.roles, id=role_id)

        if role is not None:
            await ctx.author.add_roles(role)
            await ctx.send(f"Bienvenue au {role.mention} !! :tada:")
        else:
            await ctx.send(
                f"{who.mention} n'a pas encore de fan club. Peut-être qu'un jour "
                f"iel sera un membre influent du CNO ?"
            )

    @command(name="calc", aliases=["="])
    async def calc_cmd(self, ctx, *args):
        """Effectue un calcul simple"""
        with_tb = has_role(ctx.author, Role.DEV)
        embed = self._calc(ctx.message.content, with_tb)
        resp = await ctx.send(embed=embed)

        def check(before, after):
            return after.id == ctx.message.id

        while True:
            try:
                before, after = await self.bot.wait_for(
                    "message_edit", check=check, timeout=600
                )
            except asyncio.TimeoutError:
                break

            embed = self._calc(after.content, with_tb)
            await resp.edit(embed=embed)

        # Remove the "You may edit your message"
        embed.set_footer()
        try:
            await resp.edit(embed=embed)
        except discord.NotFound:
            pass

    def _calc(self, query: str, with_tb=False):

        for prefix in ("! ", "!", "calc", "="):
            if query.startswith(prefix):
                query = query[len(prefix):]
        query = re.sub(r"\b((\d)+(\.\d+)?)(?P<name>[a-zA-Z]+)\b", r"\1*\4", query)

        query = query.strip().strip("`")

        ex = None
        result = 42
        try:
            result = self._eval(ast.parse(query, mode='eval').body)
        except Exception as e:
            ex = e

        if isinstance(result, complex):
            if abs(result.imag) < 1e-12:
                result = result.real
            else:
                r, i = result.real, result.imag
                r = r if abs(int(r) - r) > 1e-12 else int(r)
                i = i if abs(int(i) - i) > 1e-12 else int(i)
                if not r:
                    result = f"{i if i != 1 else ''}i"
                else:
                    result = f"{r}{i if i != 1 else '':+}i"
        if isinstance(result, float):
            result = round(result, 12)

        embed = discord.Embed(title=discord.utils.escape_markdown(query), color=EMBED_COLOR)
        # embed.add_field(name="Entrée", value=f"`{query}`", inline=False)
        embed.add_field(name="Valeur", value=f"`{result}`", inline=False)
        if ex and with_tb:
            embed.add_field(name="Erreur", value=f"{ex.__class__.__name__}: {ex}", inline=False)
            trace = io.StringIO()
            traceback.print_exception(type(ex), ex, ex.__traceback__, file=trace)
            trace.seek(0)
            embed.add_field(name="Traceback", value=f"```\n{trace.read()}```")
        embed.set_footer(text="You may edit your message")

        return embed

    def _eval(self, node):
        if isinstance(node, ast.Num):  # <number>
            return node.n
        elif isinstance(node, ast.BinOp):  # <left> <operator> <right>
            return OPS[type(node.op)](self._eval(node.left), self._eval(node.right))
        elif isinstance(node, ast.UnaryOp):  # <operator> <operand> e.g., -1
            return OPS[type(node.op)](self._eval(node.operand))
        elif isinstance(node, ast.Call):
            if isinstance(node.func, ast.Name):
                return OPS[node.func.id](*(self._eval(n) for n in node.args), **{k.arg: self._eval(k.value) for k in node.keywords})
        elif isinstance(node, ast.Name):
            return OPS[node.id]

        fields = ", ".join(
            f"{k}={getattr(node, k).__class__.__name__}" for k in node._fields
        )
        raise TypeError(f"Type de noeud non supporté: {node.__class__.__name__}({fields})")


    # ----------------- Hugs ---------------- #

    @command(aliases=["<3", "❤️", ":heart:", Emoji.RAINBOW_HEART])
    async def hug(self, ctx: Context, who="everyone"):
        """Fait un câlin à quelqu'un. :heart:"""

        if who == "everyone":
            who = ctx.guild.default_role
        elif who == "back":
            return await self.hug_back(ctx)
        else:
            try:
                who = await RoleConverter().convert(ctx, who)
            except BadArgument:
                try:
                    who = await MemberConverter().convert(ctx, who)
                except BadArgument:
                    return await ctx.send(
                        discord.utils.escape_mentions(
                            f'Il n\'y a pas de "{who}". :man_shrugging:'
                        )
                    )
        who: Union[discord.Role, Member]
        bot_hug = who == self.bot.user

        bonuses = [
            "C'est trop meuuuugnon !",
            "Ça remonte le moral ! :D",
            ":hugging:",
            ":smiling_face_with_3_hearts:",
            "Oh wiiii",
            # f"{'Je me sens' if bot_hug else 'Iel se sent'} désormais prêt à travailler à fond sur les solutions de AQT",
            f"{who.mention} en redemande un !"
            if not bot_hug
            else "J'en veux un autre ! :heart_eyes:",
            "Le·a pauvre, iel est tout·e rouge !"
            if not bot_hug
            else "Un robot ne peut pas rougir, mais je crois que... :blush:",
            "Hihi, il gratte ton pull en laine ! :sheep:",
        ]

        if (
            isinstance(who, discord.Member)
            and has_role(who, Role.JURY)
            and has_role(ctx.author, Role.PARTICIPANT)
        ):
            bonuses += ["Il s'agit surement là d'une tentative de corruption !"]

        if has_role(ctx.author, Role.PRETRESSE_CALINS):
            bonuses += [
                "C'est le plus beau calin du monde :smiling_face_with_3_hearts: :smiling_face_with_3_hearts:",
                f"{who.mention} est subjugué·e ! :smiling_face_with_3_hearts:",
            ]

        if who.id == DIEGO:
            bonuses += [
                "Tiens... Ça sent le mojito... :lemon:",
                ":green_heart: :lemon: :green_heart:",
            ]

        if who.id in FAN_CLUBS and not get(ctx.author.roles, id=FAN_CLUBS[who.id]):
            bonuses += ["Tu devrais rejoindre son fan club :wink:"]

        if who == ctx.author:
            msg = f"{who.mention} se fait un auto-calin !"
            bonuses += [
                "Mais c'est un peu ridicule...",
                "Mais iel a les bras trop courts ! :cactus:",
                "Il en faut peu pour être heureux :wink:",
            ]
        elif who == ctx.guild.default_role:
            msg = f"{ctx.author.mention} fait un câlin a touuuut le monde !"
            bonuses += [
                "Ça fait beaucoup de gens pour un câlin !",
                "Plus on est, plus on est calins !",
                "C'est pas très COVID-19 tout ça !",
                "Tout le monde est heureux maintenant !",
            ]
        elif bot_hug:
            msg = f"{ctx.author.mention} me fait un gros câliiiiin !"
            bonuses += ["Je trouve ça très bienveillant <3"]
        else:
            msg = f"{ctx.author.mention} fait un gros câlin à {who.mention} !"
            bonuses += [
                f"Mais {who.mention} n'apprécie pas...",
                "Et ils s'en vont chasser des canards ensemble :wink:",
                "Oh ! Iel sent bon...",
                "Et moi quand est ce que j'ai le droit à un calin ?",
                f"{who.mention} a serré tellment fort qu'iel vous a coupé en deux :scream:",
                f"{who.mention} propose à {ctx.author.mention} de se revoir autour d'une :pizza: !",
                "Les drones du commissaire Winston passent par là et vous ordonnent d'arrêter.",
                "Après ce beau moment de tendresse, ils décident d'aller discuter en créant des puzzles.",
                f"{who.mention} se réfugie dans l'entrepôt d'Animath et bloque l'entrée avec un meuble.",
            ]

        bonus = random.choice(bonuses)

        text = f"{msg} {bonus}"
        self.add_hug(ctx.author.id, who.id, text)

        await ctx.send(text)

        if bot_hug and random.random() > 0.9:
            await asyncio.sleep(3.14159265358979323)
            ctx.author = get(ctx.guild.members, id=self.bot.user.id)
            await ctx.invoke(self.hug, "back")

    async def hug_back(self, ctx: Context):
        hugger = ctx.author.id

        last_hug: Hug = get(reversed(self.hugs), hugged=hugger)
        if not last_hug:
            return await ctx.send(
                f"Personne n'a jamais fait de calin à {ctx.author.mention}, il faut y remédier !"
            )

        if "coupé en deux" in last_hug.text:
            return await ctx.send(
                "Tu ne vas quand même pas faire un câlin à quelqu'un "
                "que tu viens de couper en deux !"
            )

        await ctx.invoke(self.hug, str(last_hug.hugger))

    @command(name="hug-stats", aliases=["hs"])
    @commands.has_role(Role.PRETRESSE_CALINS)
    async def hugs_stats_cmd(self, ctx: Context, who: Member = None):
        """(prêtresse des calins) Affiche qui est le plus câliné """

        if who is None:
            await self.send_all_hug_stats(ctx)
        else:
            await self.send_hugs_stats_for(ctx, who)

    async def send_all_hug_stats(self, ctx):
        medals = [
            ":first_place:",
            ":second_place:",
            ":third_place:",
            ":medal:",
            ":military_medal:",
        ]
        ranks = ["Gros Nounours", "Petit Panda", "Ours en peluche"]

        embed = discord.Embed(
            title="Prix du plus câliné",
            color=discord.Colour.magenta(),
            description=f"Nombre de total de câlins : {len(self.hugs)} {Emoji.HEART}",
        )

        everyone = ctx.guild.default_role.id
        everyone_hugs = 0
        everyone_diff = set()
        stats = Counter()
        diffs = defaultdict(set)
        for h in self.hugs:
            if h.hugged == everyone:
                everyone_hugs += 1
                everyone_diff.add(h.hugger)
            else:
                if h.hugged != h.hugger:
                    stats[h.hugged] += 1
                    diffs[h.hugged].add(h.hugger)

                role: discord.Role = get(ctx.guild.roles, id=h.hugged)
                if role is not None:
                    for m in role.members:
                        if m.id != h.hugger:
                            stats[m.id] += 1
                            diffs[m.id].add(h.hugger)

        for m, d in diffs.items():
            stats[m] += len(everyone_diff.union(d)) * 42 + everyone_hugs

        top = sorted(list(stats.items()), key=itemgetter(1), reverse=True)

        for i in range(3):
            m = medals[i]
            r = ranks[i]
            id, qte = top[i]
            who = self.name_for(ctx, id)

            embed.add_field(name=f"{m} - {r}", value=f"{who} : {qte}  :heart:")

        top4to7 = "\n ".join(
            f"{medals[3]} {self.name_for(ctx, id)} : {qte}  :orange_heart:"
            for id, qte in top[3:8]
        )
        embed.add_field(name="Apprenti peluche", value=top4to7)

        top8to13 = "\n".join(
            f"{medals[4]} {self.name_for(ctx, id)} : {qte}  :yellow_heart:"
            for id, qte in top[8:13]
        )
        embed.add_field(name="Pelote de laine de canard", value=top8to13)

        await ctx.send(embed=embed)

    async def send_hugs_stats_for(self, ctx: Context, who: discord.Member):

        given = self.hugs_given(ctx, who.id)
        received = self.hugs_received(ctx, who.id)
        auto = self.auto_hugs(ctx, who.id)
        cut = [h for h in given if "coupé en deux" in h.text]
        infos = {
            "Câlins donnés": (len(given), 1),
            "Câlins reçus": (len(received), 1),
            "Personnes câlinées": (len(set(h.hugged for h in given)), 20),
            "Câliné par": (len(set(h.hugger for h in received)), 30),
            "Auto-câlins": ((len(auto)), 3),
            "Morceaux": (len(cut), 30),
        }

        most_given = Counter(h.hugged for h in given).most_common(1)
        most_received = Counter(h.hugger for h in received).most_common(1)
        most_given = most_given[0] if most_given else (0, 0)
        most_received = most_received[0] if most_received else (0, 0)

        embed = discord.Embed(
            title=f"Câlins de {who.display_name}",
            color=discord.Colour.magenta(),
            description=(
                f"On peut dire que {who.mention} est très câlin·e, avec un score de "
                f"{self.score_for(ctx, who.id)}. Iel a beaucoup câliné "
                f"{self.name_for(ctx, most_given[0])} "
                f"*({most_given[1]} :heart:)* et "
                f"s'est beaucoup fait câliner par {self.name_for(ctx, most_received[0])} "
                f"*({most_received[1]} :heart:)* !"
            ),
        )
        user: discord.User = self.bot.get_user(who.id)
        embed.set_thumbnail(url=user.avatar_url)

        for f, (v, h_factor) in infos.items():
            heart = self.heart_for_stat(v * h_factor)
            if f == "Morceaux":
                v = 2 ** v
            embed.add_field(name=f, value=f"{v} {heart}")

        await ctx.send(embed=embed)

    def ris(self, ctx: Context, id, role_or_member_id):
        """Whether the id is the same member or a member that has the given role."""
        if id == role_or_member_id:
            return True

        member: Member = get(ctx.guild.members, id=id)

        if member is None:
            return False

        role = get(member.roles, id=role_or_member_id)

        return role is not None

    def heart_for_stat(self, v):
        hearts = [
            ":broken_heart:",
            ":green_heart:",
            ":yellow_heart:",
            ":orange_heart:",
            ":heart:",
            ":sparkling_heart:",
            Emoji.RAINBOW_HEART,
        ]

        if v <= 0:
            return hearts[0]
        elif v >= 5000:
            return hearts[-1]
        elif v >= 2000:
            return hearts[-2]
        else:
            return hearts[len(str(v))]

    def name_for(self, ctx, member_or_role_id):
        memb = ctx.guild.get_member(member_or_role_id)
        if memb is not None:
            name = memb.mention
        else:
            role = ctx.guild.get_role(member_or_role_id)
            if role is None:
                name = getattr(
                    self.bot.get_user(member_or_role_id), "mention", "Personne"
                )
            else:
                name = role.name

        return name

    def score_for(self, ctx, member_id):
        received = self.hugs_received(ctx, member_id)
        diffs = set(h.hugger for h in received)
        return 42 * len(diffs) + len(received)

    def hugs_given(self, ctx, who_id):
        eq = partial(self.ris, ctx, who_id)
        return [h for h in self.hugs if eq(h.hugger) and not eq(h.hugged)]

    def hugs_received(self, ctx, who_id):
        eq = partial(self.ris, ctx, who_id)
        return [h for h in self.hugs if eq(h.hugged) and not eq(h.hugger)]

    def auto_hugs(self, ctx, who_id):
        eq = partial(self.ris, ctx, who_id)
        return [h for h in self.hugs if eq(h.hugged) and eq(h.hugger)]

    def get_hugs(self):
        File.HUGS.touch()
        lines = File.HUGS.read_text().strip().splitlines()
        return [Hug.from_str(l) for l in lines]

    def add_hug(self, hugger: int, hugged: int, text):
        File.HUGS.touch()
        with open(File.HUGS, "a") as f:
            f.write(f"{hugger} -> {hugged} | {text}\n")
        self.hugs.append(Hug(hugger, hugged, text))

    # ---------------- Jokes ---------------- #

    def load_jokes(self) -> List[Joke]:
        # Ensure it exists
        File.JOKES_V2.touch()
        with open(File.JOKES_V2) as f:
            jokes = list(yaml.safe_load_all(f))

        return jokes

    def save_jokes(self, jokes):
        File.JOKES_V2.touch()
        with open(File.JOKES_V2, "w") as f:
            yaml.safe_dump_all(jokes, f)

    @group(name="joke", invoke_without_command=True, case_insensitive=True)
    async def joke(self, ctx: Context, id=None):
        """Fait discretement une blague aléatoire."""

        m: discord.Message = ctx.message
        await m.delete()

        jokes = self.load_jokes()
        if id is not None:
            id = int(id)
            joke_id = id
            jokes = sorted(
                jokes, key=lambda j: len(j.likes) - len(j.dislikes), reverse=True
            )
        else:
            joke_id = random.randrange(len(jokes))

        try:
            joke = jokes[joke_id]
        except IndexError:
            raise TfjmError("Il n'y a pas de blague avec cet ID.")

        if joke.file:
            file = discord.File(File.MEMES / joke.file)
        else:
            file = None

        message: discord.Message = await ctx.send(joke.joke, file=file)

        await message.add_reaction(Emoji.PLUS_1)
        await message.add_reaction(Emoji.MINUS_1)
        await self.wait_for_joke_reactions(joke_id, message)

    @joke.command(name="new")
    @send_and_bin
    async def new_joke(self, ctx: Context):
        """Ajoute une blague pour le concours de blague."""
        jokes = self.load_jokes()
        joke_id = len(jokes)

        author: discord.Member = ctx.author
        message: discord.Message = ctx.message

        msg = message.content[len("!joke new ") :]

        joke = Joke(msg, ctx.author.id, set())

        if message.attachments:
            file: discord.Attachment = message.attachments[0]
            joke.file = str(f"{joke_id}-{file.filename}")
            await file.save(File.MEMES / joke.file)
        elif not msg.strip():
            return "Tu ne peux pas ajouter une blague vide..."

        jokes.append(joke)
        self.save_jokes(jokes)
        await message.add_reaction(Emoji.PLUS_1)
        await message.add_reaction(Emoji.MINUS_1)

        await self.wait_for_joke_reactions(joke_id, message)

    async def wait_for_joke_reactions(self, joke_id, message):
        def check(reaction: discord.Reaction, u):
            return (message.id == reaction.message.id) and str(reaction.emoji) in (
                Emoji.PLUS_1,
                Emoji.MINUS_1,
            )

        start = time()
        end = start + 24 * 60 * 60 * 5  # 5 days
        while time() < end:

            try:
                reaction, user = await self.bot.wait_for(
                    "reaction_add", check=check, timeout=end - time()
                )
            except asyncio.TimeoutError:
                return

            if user.id == BOT:
                continue

            jokes = self.load_jokes()
            if str(reaction.emoji) == Emoji.PLUS_1:
                jokes[joke_id].likes.add(user.id)
            else:
                jokes[joke_id].dislikes.add(user.id)

            self.save_jokes(jokes)

    @joke.command(name="top", hidden=True)
    @commands.has_any_role(*Role.ORGAS)
    async def best_jokes(self, ctx: Context):
        """Affiche le palmares des blagues."""

        jokes = self.load_jokes()

        s = sorted(jokes, key=lambda j: len(j.likes) - len(j.dislikes), reverse=True)

        embed = discord.Embed(title="Palmares des blagues.")
        for i, joke in enumerate(s[:10]):
            who = get(ctx.guild.members, id=joke.joker)

            text = joke.joke
            if joke.file:
                text += " - image non inclue - "

            name = who.display_name if who else "Inconnu"
            embed.add_field(
                name=f"{i} - {name} - {len(joke.likes)} :heart: {len(joke.dislikes)} :broken_heart:", value=text, inline=False
            )

        await ctx.send(embed=embed)

    # ----------------- Help ---------------- #

    @command(name="help", aliases=["h"])
    async def help_cmd(self, ctx: Context, *args):
        """Affiche des détails à propos d'une commande."""

        if not args:
            msg = await self.send_bot_help(ctx)
        else:
            msg = await self.send_command_help(ctx, args)

        await self.bot.wait_for_bin(ctx.author, msg)

    async def send_bot_help(self, ctx: Context):
        embed = discord.Embed(
            title="Aide pour le bot du TFJM²",
            description="Ici est une liste des commandes utiles (ou pas) "
            "durant le tournoi. Pour avoir plus de détails il "
            "suffit d'écrire `!help COMMANDE` en remplacant `COMMANDE` "
            "par le nom de la commande, par exemple `!help team channel`.",
            color=0xFFA500,
        )

        cog_getter = attrgetter("cog_name")
        commands = itertools.groupby(sorted(self.bot.walk_commands(), key=cog_getter), cog_getter)

        for cat_name, cat in commands:
            cat = {c.qualified_name: c for c in cat}
            cat = await self.filter_commands(
                ctx, list(cat.values()), sort=True, key=attrgetter("qualified_name")
            )

            if not cat:
                continue

            names = ["!" + c.qualified_name for c in cat]
            width = max(map(len, names))
            names = [name.rjust(width) for name in names]
            short_help = [c.short_doc for c in cat]

            lines = [f"`{n}` - {h}" for n, h in zip(names, short_help)]

            if cat_name is None:
                cat_name = "Autres"

            c: Command
            text = "\n".join(lines)
            embed.add_field(name=cat_name, value=text, inline=False)

        embed.set_footer(text="Suggestion ? Problème ? Envoie un message à @Diego")

        return await ctx.send(embed=embed)

    async def send_command_help(self, ctx, args):
        name = " ".join(args).strip("!")
        comm: Command = self.bot.get_command(name)
        if comm is None:
            return await ctx.send(
                f"La commande `!{name}` n'existe pas. "
                f"Utilise `!help` pour une liste des commandes."
            )
        elif isinstance(comm, Group):
            return await self.send_group_help(ctx, comm)

        embed = discord.Embed(
            title=f"Aide pour la commande `!{comm.qualified_name}`",
            description=comm.help,
            color=0xFFA500,
        )

        if comm.aliases:
            aliases = ", ".join(f"`{a}`" for a in comm.aliases)
            embed.add_field(name="Alias", value=aliases, inline=True)
        if comm.signature:
            embed.add_field(
                name="Usage", value=f"`!{comm.qualified_name} {comm.signature}`"
            )
        embed.set_footer(text="Suggestion ? Problème ? Envoie un message à @Diego")

        return await ctx.send(embed=embed)

    async def send_group_help(self, ctx, group: Group):
        embed = discord.Embed(
            title=f"Aide pour le groupe de commandes `!{group.qualified_name}`",
            description=group.help,
            color=0xFFA500,
        )

        comms = await self.filter_commands(ctx, group.commands, sort=True)
        if not comms:
            embed.add_field(
                name="Désolé", value="Il n'y a aucune commande pour toi ici."
            )
        else:
            names = ["!" + c.qualified_name for c in comms]
            width = max(map(len, names))
            just_names = [name.rjust(width) for name in names]
            short_help = [c.short_doc for c in comms]

            lines = [f"`{n}` - {h}" for n, h in zip(just_names, short_help)]

            c: Command
            text = "\n".join(lines)
            embed.add_field(name="Sous-commandes", value=text, inline=False)

            if group.aliases:
                aliases = ", ".join(f"`{a}`" for a in group.aliases)
                embed.add_field(name="Alias", value=aliases, inline=True)
            if group.signature:
                embed.add_field(
                    name="Usage", value=f"`!{group.qualified_name} {group.signature}`"
                )

            embed.add_field(
                name="Plus d'aide",
                value=f"Pour plus de détails sur une commande, "
                f"il faut écrire `!help COMMANDE` en remplaçant "
                f"COMMANDE par le nom de la commande qui t'intéresse.\n"
                f"Exemple: `!help {random.choice(names)[1:]}`",
            )
        embed.set_footer(text="Suggestion ? Problème ? Envoie un message à @Diego")

        return await ctx.send(embed=embed)

    def _name(self, command: Command):
        return f"`!{command.qualified_name}`"

    async def filter_commands(self, ctx, commands, *, sort=False, key=None):
        """|coro|

        Returns a filtered list of commands and optionally sorts them.

        This takes into account the :attr:`verify_checks` and :attr:`show_hidden`
        attributes.

        Parameters
        ------------
        commands: Iterable[:class:`Command`]
            An iterable of commands that are getting filtered.
        sort: :class:`bool`
            Whether to sort the result.
        key: Optional[Callable[:class:`Command`, Any]]
            An optional key function to pass to :func:`py:sorted` that
            takes a :class:`Command` as its sole parameter. If ``sort`` is
            passed as ``True`` then this will default as the command name.

        Returns
        ---------
        List[:class:`Command`]
            A list of commands that passed the filter.
        """

        if sort and key is None:
            key = lambda c: c.qualified_name

        iterator = (
            commands if self.show_hidden else filter(lambda c: not c.hidden, commands)
        )

        if not self.verify_checks:
            # if we do not need to verify the checks then we can just
            # run it straight through normally without using await.
            return sorted(iterator, key=key) if sort else list(iterator)

        # if we're here then we need to check every command if it can run
        async def predicate(cmd):
            try:
                return await cmd.can_run(ctx)
            except CommandError:
                return False

        ret = []
        for cmd in iterator:
            valid = await predicate(cmd)
            if valid:
                ret.append(cmd)

        if sort:
            ret.sort(key=key)
        return ret


def setup(bot: CustomBot):
    bot.add_cog(MiscCog(bot))