import logging
import math
from datetime import datetime, timedelta
from typing import Literal, Union

import discord
from redbot.core import Config, bank, checks, commands
from redbot.core.bot import Red
from redbot.core.i18n import Translator, cog_i18n
from redbot.core.utils import AsyncIter
from redbot.core.utils.chat_formatting import box, humanize_timedelta
from tabulate import tabulate

log = logging.getLogger("red.yamicogs.payday")

_ = Translator("Talk", __file__)


def cmd_check(option):
    async def pred(ctx: commands.Context):
        if await bank.is_global():
            if await ctx.bot.get_cog("PayDay").config.get_raw(option) > 0:
                return True
        elif not await bank.is_global() and ctx.guild is not None:
            if await ctx.bot.get_cog("PayDay").config.guild(ctx.guild).get_raw(option) > 0:
                return True
        else:
            return False

    return commands.check(pred)


def cmd_all():
    async def pred(ctx: commands.Context):
        if await bank.is_global():
            return True
        elif not await bank.is_global() and ctx.guild is not None:
            return True
        else:
            return False

    return commands.check(pred)


# taken from Red-Discordbot economy.py
def guild_only_check():
    async def pred(ctx: commands.Context):
        if await bank.is_global():
            return True
        elif not await bank.is_global() and ctx.guild is not None:
            return True
        else:
            return False

    return commands.check(pred)


# taken from Red-Discordbot bank.py
def is_owner_if_bank_global():
    """
    Command decorator. If the bank is global, it checks if the author is
    bot owner, otherwise it only checks
    if command was used in guild - it DOES NOT check any permissions.
    When used on the command, this should be combined
    with permissions check like `guildowner_or_permissions()`.
    """

    async def pred(ctx: commands.Context):
        author = ctx.author
        if not await bank.is_global():
            if not ctx.guild:
                return False
            return True
        else:
            return await ctx.bot.is_owner(author)

    return commands.check(pred)


@cog_i18n(_)
class PayDay(commands.Cog):
    """
    Customizable PayDay system

    More detailed docs: <https://cogs.yamikaitou.dev/payday.html>
    """

    settings = {"day": 1, "week": 7, "month": 30, "quarter": 91, "year": 365}
    friendly = {
        "hour": "Hourly",
        "day": "Daily",
        "week": "Weekly",
        "month": "Monthly",
        "quarter": "Quarterly",
        "year": "Yearly",
    }
    times = {
        "hour": 1,
        "day": 24,
        "week": 168,
        "month": 720,
        "quarter": 2184,
        "year": 8760,
    }

    def __init__(self, bot: Red):
        self.bot = bot
        self.config = Config.get_conf(self, identifier=582650109, force_registration=True)

        default_config = {
            "hour": 0,
            "day": 0,
            "week": 0,
            "month": 0,
            "quarter": 0,
            "year": 0,
            "streaks": {
                "hour": 0,
                "day": 0,
                "week": 0,
                "month": 0,
                "quarter": 0,
                "year": 0,
                "percent": False,
            },
        }
        default_user = {
            "hour": "2016-01-02T04:25:00-04:00",
            "day": "2016-01-02T04:25:00-04:00",
            "week": "2016-01-02T04:25:00-04:00",
            "month": "2016-01-02T04:25:00-04:00",
            "quarter": "2016-01-02T04:25:00-04:00",
            "year": "2016-01-02T04:25:00-04:00",
        }

        self.config.register_global(**default_config)
        self.config.register_guild(**default_config)
        self.config.register_member(**default_user)
        self.config.register_user(**default_user)

    @guild_only_check()
    @commands.group()
    async def freecredits(self, ctx):
        """More options to get free credits"""

    @cmd_all()
    @freecredits.command(name="times")
    async def freecredits_times(self, ctx):
        """Display remaining time for all options"""

        if await bank.is_global():
            amounts = await self.config.all()
            times = await self.config.user(ctx.author).all()
        else:
            amounts = await self.config.guild(ctx.guild).all()
            times = await self.config.member(ctx.author).all()

        now = datetime.now().astimezone().replace(microsecond=0)
        strings = ""

        if amounts["hour"]:
            td = now - datetime.fromisoformat(times["hour"])
            strings += (
                self.friendly["hour"]
                + ": "
                + (
                    humanize_timedelta(timedelta=(timedelta(hours=1) - td))
                    if td.seconds < 3600
                    else _("Available Now!")
                )
                + "\n"
            )

        for k, v in self.settings.items():
            if amounts[k]:
                td = now - (datetime.fromisoformat(times[k]))
                strings += (
                    self.friendly[k]
                    + ": "
                    + (
                        humanize_timedelta(timedelta=(timedelta(days=v) - td))
                        if td.days < v
                        else _("Available Now!")
                    )
                    + "\n"
                )
        if strings == "":
            await ctx.send(_("No freecredit options have been configured yet"))
        else:
            await ctx.send(strings)

    @cmd_all()
    @freecredits.command(name="all")
    async def freecredits_all(self, ctx):
        """Claim all available freecredits"""

        total_amount = 0
        total_streak = 0

        for k in self.friendly:
            free, streak, remain = await self.grant_award(ctx, k, False)
            if remain != -1:
                continue
            elif streak != -1:
                total_amount += free
                total_streak += streak
            elif free != -1:
                total_amount += free

        bankname = await bank.get_currency_name(ctx.guild)
        if total_streak > 0:
            await bank.deposit_credits(ctx.author, total_amount + total_streak)
            await ctx.send(
                _(
                    "You have claimed all available {bankname} from the `freecredits` program! +{total_amount} {bankname}\nPlus an additional {total_streak} for maintaining your streaks"
                ).format(bankname=bankname, total_amount=total_amount, total_streak=total_streak)
            )
        elif total_amount > 0:
            await bank.deposit_credits(ctx.author, total_amount)
            await ctx.send(
                _(
                    "You have claimed all available {bankname} from the `freecredits` program! +{total_amount} {bankname}"
                ).format(bankname=bankname, total_amount=total_amount)
            )
        else:
            await ctx.send(
                _("You have no available {bankname} for claiming.").format(bankname=bankname)
            )

    @cmd_check("hour")
    @freecredits.command(name="hourly")
    async def freecredits_hourly(self, ctx):
        """Get some free currency every hour"""

        free, streak, remain = await self.grant_award(ctx, "hour")

        if remain != -1:
            await ctx.send(
                _("Sorry, you still have {remain} until your next hourly bonus").format(
                    remain=remain
                )
            )
        elif streak != -1:
            await ctx.send(
                _(
                    "You have been given {free_credits} {bankname} plus {streak_bonus} for maintaining a streak"
                ).format(
                    free_credits=free,
                    bankname=(await bank.get_currency_name(ctx.guild)),
                    streak_bonus=streak,
                )
            )
        elif free != -1:
            await ctx.send(
                _("You have been given {free_credits} {bankname}").format(
                    free_credits=free, bankname=(await bank.get_currency_name(ctx.guild))
                )
            )
        else:
            log.debug("grant_award returned no results")

    @cmd_check("day")
    @freecredits.command(name="daily")
    async def freecredits_daily(self, ctx):
        """Get some free currency every day"""

        free, streak, remain = await self.grant_award(ctx, "day")

        if remain != -1:
            await ctx.send(
                _("Sorry, you still have {remain} until your next dailya bonus").format(
                    remain=remain
                )
            )
        elif streak != -1:
            await ctx.send(
                _(
                    "You have been given {free_credits} {bankname} plus {streak_bonus} for maintaining a streak"
                ).format(
                    free_credits=free,
                    bankname=(await bank.get_currency_name(ctx.guild)),
                    streak_bonus=streak,
                )
            )
        elif free != -1:
            await ctx.send(
                _("You have been given {free_credits} {bankname}").format(
                    free_credits=free, bankname=(await bank.get_currency_name(ctx.guild))
                )
            )
        else:
            log.debug("grant_award returned no results")

    @cmd_check("week")
    @freecredits.command(name="weekly")
    async def freecredits_weekly(self, ctx):
        """Get some free currency every week (7 days)"""

        free, streak, remain = await self.grant_award(ctx, "week")

        if remain != -1:
            await ctx.send(
                _("Sorry, you still have {remain} until your next weekly bonus").format(
                    remain=remain
                )
            )
        elif streak != -1:
            await ctx.send(
                _(
                    "You have been given {free_credits} {bankname} plus {streak_bonus} for maintaining a streak"
                ).format(
                    free_credits=free,
                    bankname=(await bank.get_currency_name(ctx.guild)),
                    streak_bonus=streak,
                )
            )
        elif free != -1:
            await ctx.send(
                _("You have been given {free_credits} {bankname}").format(
                    free_credits=free, bankname=(await bank.get_currency_name(ctx.guild))
                )
            )
        else:
            log.debug("grant_award returned no results")

    @cmd_check("month")
    @freecredits.command(name="monthly")
    async def freecredits_monthly(self, ctx):
        """Get some free currency every month (30 days)"""

        free, streak, remain = await self.grant_award(ctx, "month")

        if remain != -1:
            await ctx.send(
                _("Sorry, you still have {remain} until your next monthly bonus").format(
                    remain=remain
                )
            )
        elif streak != -1:
            await ctx.send(
                _(
                    "You have been given {free_credits} {bankname} plus {streak_bonus} for maintaining a streak"
                ).format(
                    free_credits=free,
                    bankname=(await bank.get_currency_name(ctx.guild)),
                    streak_bonus=streak,
                )
            )
        elif free != -1:
            await ctx.send(
                _("You have been given {free_credits} {bankname}").format(
                    free_credits=free, bankname=(await bank.get_currency_name(ctx.guild))
                )
            )
        else:
            log.debug("grant_award returned no results")

    @cmd_check("quarter")
    @freecredits.command(name="quarterly")
    async def freecredits_quarterly(self, ctx):
        """Get some free currency every quarter (122 days)"""

        free, streak, remain = await self.grant_award(ctx, "quarter")

        if remain != -1:
            await ctx.send(
                _("Sorry, you still have {remain} until your next quarterly bonus").format(
                    remain=remain
                )
            )
        elif streak != -1:
            await ctx.send(
                _(
                    "You have been given {free_credits} {bankname} plus {streak_bonus} for maintaining a streak"
                ).format(
                    free_credits=free,
                    bankname=(await bank.get_currency_name(ctx.guild)),
                    streak_bonus=streak,
                )
            )
        elif free != -1:
            await ctx.send(
                _("You have been given {free_credits} {bankname}").format(
                    free_credits=free, bankname=(await bank.get_currency_name(ctx.guild))
                )
            )
        else:
            log.debug("grant_award returned no results")

    @cmd_check("year")
    @freecredits.command(name="yearly")
    async def freecredits_yearly(self, ctx):
        """Get some free currency every year (365 days)"""

        free, streak, remain = await self.grant_award(ctx, "year")

        if remain != -1:
            await ctx.send(
                _("Sorry, you still have {remain} until your next yearly bonus").format(
                    remain=remain
                )
            )
        elif streak != -1:
            await ctx.send(
                _(
                    "You have been given {free_credits} {bankname} plus {streak_bonus} for maintaining a streak"
                ).format(
                    free_credits=free,
                    bankname=(await bank.get_currency_name(ctx.guild)),
                    streak_bonus=streak,
                )
            )
        elif free != -1:
            await ctx.send(
                _("You have been given {free_credits} {bankname}").format(
                    free_credits=free, bankname=(await bank.get_currency_name(ctx.guild))
                )
            )
        else:
            log.debug("grant_award returned no results")

    async def grant_award(self, ctx, option, deposit=True):
        if await bank.is_global():
            free = await self.config.get_raw(option)
            streak = await self.config.streaks.get_raw(option)
            perc = await self.config.streaks.percent()
            config = self.config.user(ctx.author)
        else:
            free = await self.config.guild(ctx.guild).get_raw(option)
            streak = await self.config.guild(ctx.guild).streaks.get_raw(option)
            perc = await self.config.guild(ctx.guild).streaks.percent()
            config = self.config.member(ctx.author)

        if free > 0:
            last = datetime.fromisoformat(await config.get_raw(option))
            now = datetime.now().astimezone().replace(microsecond=0)

            if streak > 0 and (
                timedelta(hours=(self.times[option] * 2))
                > (now - last)
                >= timedelta(hours=self.times[option])
            ):
                if perc:
                    streak = free * math.floor(streak / 100)
                if deposit:
                    await bank.deposit_credits(ctx.author, free + streak)
                await config.set_raw(option, value=now.isoformat())
                return (free, streak, -1)
            elif (now - last) >= timedelta(hours=self.times[option]):
                if deposit:
                    await bank.deposit_credits(ctx.author, free)
                await config.set_raw(option, value=now.isoformat())
                return (free, -1, -1)
            else:
                return (
                    0,
                    0,
                    humanize_timedelta(
                        timedelta=(timedelta(hours=self.times[option]) - (now - last))
                    ),
                )

        return (-1, -1, -1)

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @commands.group()
    async def pdconfig(self, ctx):
        """
        Configure the `freecredits` options

        More detailed docs: <https://cogs.yamikaitou.dev/payday.html#pdconfig>
        """

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig.command(name="settings")
    async def pdconfig_info(self, ctx):
        """Print the `freecredits` options"""

        if await bank.is_global():
            conf = await self.config.all()
            await ctx.send(box(tabulate(conf.items())))
        else:
            conf = await self.config.guild(ctx.guild).all()
            await ctx.send(box(tabulate(conf.items())))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig.command(name="hourly", aliases=["hour"])
    async def pdconfig_hourly(self, ctx, value: int):
        """
        Configure the `hourly` options

        Setting this to 0 will disable the command
        """

        if value < 0:
            return await ctx.send(_("You must provide a non-negative value or 0"))
        try:
            if await bank.is_global():
                await self.config.hour.set(value)
            else:
                await self.config.guild(ctx.guild).hour.set(value)
        except Exception as e:
            raise e
        else:
            if not await ctx.tick():
                await ctx.send(_("Setting saved"))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig.command(name="daily", aliases=["day"])
    async def pdconfig_daily(self, ctx, value: int):
        """
        Configure the `daily` options

        Setting this to 0 will disable the command"""

        if value < 0:
            return await ctx.send(_("You must provide a non-negative value or 0"))
        try:
            if await bank.is_global():
                await self.config.day.set(value)
            else:
                await self.config.guild(ctx.guild).day.set(value)
        except Exception as e:
            raise e
        else:
            if not await ctx.tick():
                await ctx.send(_("Setting saved"))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig.command(name="weekly", aliases=["week"])
    async def pdconfig_weekly(self, ctx, value: int):
        """
        Configure the `weekly` options

        Setting this to 0 will disable the command
        """

        if value < 0:
            return await ctx.send(_("You must provide a non-negative value or 0"))
        try:
            if await bank.is_global():
                await self.config.week.set(value)
            else:
                await self.config.guild(ctx.guild).week.set(value)
        except Exception as e:
            raise e
        else:
            if not await ctx.tick():
                await ctx.send(_("Setting saved"))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig.command(name="monthly", aliases=["month"])
    async def pdconfig_monthly(self, ctx, value: int):
        """
        Configure the `monthly` options

        Setting this to 0 will disable the command
        """

        if value < 0:
            return await ctx.send(_("You must provide a non-negative value or 0"))
        try:
            if await bank.is_global():
                await self.config.month.set(value)
            else:
                await self.config.guild(ctx.guild).month.set(value)
        except Exception as e:
            raise e
        else:
            if not await ctx.tick():
                await ctx.send(_("Setting saved"))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig.command(name="quarterly", aliases=["quarter"])
    async def pdconfig_quarterly(self, ctx, value: int):
        """
        Configure the `quarterly` options

        Setting this to 0 will disable the command
        """

        if value < 0:
            return await ctx.send(_("You must provide a non-negative value or 0"))
        try:
            if await bank.is_global():
                await self.config.quarter.set(value)
            else:
                await self.config.guild(ctx.guild).quarter.set(value)
        except Exception as e:
            raise e
        else:
            if not await ctx.tick():
                await ctx.send(_("Setting saved"))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig.command(name="yearly", aliases=["year"])
    async def pdconfig_yearly(self, ctx, value: int):
        """
        Configure the `yearly` options

        Setting this to 0 will disable the command
        """

        if value < 0:
            return await ctx.send(_("You must provide a non-negative value or 0"))
        try:
            if await bank.is_global():
                await self.config.year.set(value)
            else:
                await self.config.guild(ctx.guild).year.set(value)
        except Exception as e:
            raise e
        else:
            if not await ctx.tick():
                await ctx.send(_("Setting saved"))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig.group(name="streaks")
    async def pdconfig_streaks(self, ctx):
        """Configure the `streaks` options"""

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig_streaks.command(name="hourly", aliases=["hour"])
    async def pdconfig_streaks_hourly(self, ctx, value: int):
        """
        Configure the `hourly` streaks value

        Setting this to 0 will disable the streak bonus
        """

        if value < 0:
            return await ctx.send(_("You must provide a non-negative value or 0"))
        try:
            if await bank.is_global():
                await self.config.streaks.hour.set(value)
            else:
                await self.config.guild(ctx.guild).streaks.hour.set(value)
        except Exception as e:
            raise e
        else:
            if not await ctx.tick():
                await ctx.send(_("Setting saved"))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig_streaks.command(name="daily", aliases=["day"])
    async def pdconfig_streaks_daily(self, ctx, value: int):
        """
        Configure the `daily` streaks value

        Setting this to 0 will disable the streak bonus
        """

        if value < 0:
            return await ctx.send(_("You must provide a non-negative value or 0"))
        try:
            if await bank.is_global():
                await self.config.streaks.day.set(value)
            else:
                await self.config.guild(ctx.guild).streaks.day.set(value)
        except Exception as e:
            raise e
        else:
            if not await ctx.tick():
                await ctx.send(_("Setting saved"))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig_streaks.command(name="weekly", aliases=["week"])
    async def pdconfig_streaks_weekly(self, ctx, value: int):
        """
        Configure the `weekly` streaks value

        Setting this to 0 will disable the streak bonus
        """

        if value < 0:
            return await ctx.send(_("You must provide a non-negative value or 0"))
        try:
            if await bank.is_global():
                await self.config.streaks.week.set(value)
            else:
                await self.config.guild(ctx.guild).streaks.week.set(value)
        except Exception as e:
            raise e
        else:
            if not await ctx.tick():
                await ctx.send(_("Setting saved"))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig_streaks.command(name="monthly", aliases=["month"])
    async def pdconfig_streaks_monthly(self, ctx, value: int):
        """
        Configure the `monthly` streaks value

        Setting this to 0 will disable the streak bonus
        """

        if value < 0:
            return await ctx.send(_("You must provide a non-negative value or 0"))
        try:
            if await bank.is_global():
                await self.config.streaks.month.set(value)
            else:
                await self.config.guild(ctx.guild).streaks.month.set(value)
        except Exception as e:
            raise e
        else:
            if not await ctx.tick():
                await ctx.send(_("Setting saved"))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig_streaks.command(name="quarterly", aliases=["quarter"])
    async def pdconfig_streaks_quarterly(self, ctx, value: int):
        """
        Configure the `quarterly` streaks value

        Setting this to 0 will disable the streak bonus
        """

        if value < 0:
            return await ctx.send(_("You must provide a non-negative value or 0"))
        try:
            if await bank.is_global():
                await self.config.streaks.quarter.set(value)
            else:
                await self.config.guild(ctx.guild).streaks.quarter.set(value)
        except Exception as e:
            raise e
        else:
            if not await ctx.tick():
                await ctx.send(_("Setting saved"))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig_streaks.command(name="yearly", aliases=["year"])
    async def pdconfig_streaks_yearly(self, ctx, value: int):
        """
        Configure the `yearly` streaks value

        Setting this to 0 will disable the streak bonus
        """

        if value < 0:
            return await ctx.send(_("You must provide a non-negative value or 0"))
        try:
            if await bank.is_global():
                await self.config.streaks.year.set(value)
            else:
                await self.config.guild(ctx.guild).streaks.year.set(value)
        except Exception as e:
            raise e
        else:
            if not await ctx.tick():
                await ctx.send(_("Setting saved"))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig_streaks.command(name="percent", aliases=["percentage"])
    async def pdconfig_streaks_percentage(self, ctx, state: bool):
        """
        Configure streaks to be a percentage or flat amount

        <state> should be any of these combinations, `on/off`, `yes/no`, `1/0`, `true/false`
        """

        try:
            if await bank.is_global():
                await self.config.streaks.percent.set(state)
            else:
                await self.config.guild(ctx.guild).streaks.percent.set(state)
        except Exception as e:
            raise e
        else:
            if not await ctx.tick():
                await ctx.send(_("Setting saved"))

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig.command(name="debug", hidden=True)
    async def pdconfig_debug(self, ctx, person: Union[discord.Member, discord.User]):
        """Pull some config data for a specific user/member, useful for Support questions"""

        if await bank.is_global():
            amounts = await self.config.all()
            times = await self.config.user(person).all()

            await ctx.send(
                "```{global_label}\n{global_items}\n\n{user_label}\n{user_items}```".format(
                    global_label=_("Global Settings"),
                    global_items=tabulate(amounts.items()),
                    user_label=_("User Settings for {person}").format(person=person.id),
                    user_items=tabulate(times.items()),
                )
            )
        else:
            amounts = await self.config.guild(ctx.guild).all()
            times = await self.config.member(person).all()

            await ctx.send(
                "```{global_label}\n{global_items}\n\n{user_label}\n{user_items}```".format(
                    global_label=_("Global Settings"),
                    global_items=tabulate(amounts.items()),
                    user_label=_("Member Settings for {person}").format(person=person.id),
                    user_items=tabulate(times.items()),
                )
            )

    @is_owner_if_bank_global()
    @checks.guildowner_or_permissions(administrator=True)
    @pdconfig.command(name="reset", hidden=True)
    async def pdconfig_reset(
        self, ctx, person: Union[discord.Member, discord.User], *, options: str
    ):
        """
        Forcibly reset the time for a user. WARNING, this will allow the user to claim the credits right away

        For <options>, you can provide any combination of the following (seperate by a space to include multiple)
        hour
        day
        week
        month
        quarter
        year
        """

        try:
            if await bank.is_global():
                for opt in options.split():
                    await self.config.user(person).set_raw(opt, value="2016-01-02T04:25:00-04:00")
            else:
                for opt in options.split():
                    await self.config.member(person).set_raw(
                        opt, value="2016-01-02T04:25:00-04:00"
                    )
        except Exception as e:
            raise e
        else:
            await ctx.send(
                _("The provided times for {person} have been reset").format(
                    person=person.display_name
                )
            )

    async def red_delete_data_for_user(
        self,
        *,
        requester: Literal["discord_deleted_user", "owner", "user", "user_strict"],
        user_id: int,
    ):
        if requester == "discord_deleted_user":
            # user is deleted, just comply

            data = await self.config.all_members()
            async for guild_id, members in AsyncIter(data.items(), steps=100):
                if user_id in members:
                    await self.config.member_from_ids(guild_id, user_id).clear()

            data = await self.config.all_users()
            async for users in AsyncIter(data.items(), steps=100):
                if user_id in users:
                    await self.config.user_from_id(user_id).clear()