discord-reminder-bot/discord_reminder_bot/main.py

from __future__ import annotations

import datetime
import os
from typing import TYPE_CHECKING, Any

import discord
import sentry_sdk
from apscheduler import events
from apscheduler.events import EVENT_JOB_ERROR, EVENT_JOB_MISSED, JobExecutionEvent
from discord.abc import PrivateChannel
from discord_webhook import DiscordWebhook
from loguru import logger

from discord_reminder_bot.commands.add import add_reminder_job
from discord_reminder_bot.commands.backup import backup_reminder_job
from discord_reminder_bot.commands.cron import cron_reminder_job
from discord_reminder_bot.commands.event import add_discord_event
from discord_reminder_bot.commands.interval import interval_reminder_job
from discord_reminder_bot.commands.list import list_reminder_job
from discord_reminder_bot.commands.pause import pause_reminder_job
from discord_reminder_bot.commands.remove import remove_reminder_job
from discord_reminder_bot.commands.restore import restore_reminder_job
from discord_reminder_bot.commands.unpause import unpause_reminder
from discord_reminder_bot.settings import scheduler

if TYPE_CHECKING:
    from apscheduler.job import Job
    from discord.guild import GuildChannel
    from requests import Response


def my_listener(event: JobExecutionEvent) -> None:
    """Listener for job events.

    Args:
        event: The event that occurred.
    """
    # TODO(TheLovinator): We should save the job state to a file and send it to Discord.  # noqa: TD003
    if event.code == events.EVENT_JOB_MISSED:
        scheduled_time: str = event.scheduled_run_time.strftime("%Y-%m-%d %H:%M:%S")
        msg: str = f"Job {event.job_id} was missed! Was scheduled at {scheduled_time}"
        send_webhook(message=msg)

    if event.exception:
        with sentry_sdk.push_scope() as scope:
            scope.set_extra("job_id", event.job_id)
            scope.set_extra("scheduled_run_time", event.scheduled_run_time.isoformat() if event.scheduled_run_time else "None")
            scope.set_extra("event_code", event.code)
            sentry_sdk.capture_exception(event.exception)

        send_webhook(f"discord-reminder-bot failed to send message to Discord\n{event}")


class RemindBotClient(discord.Client):
    """The bot client for the Discord Reminder Bot."""

    def __init__(self, *, intents: discord.Intents) -> None:
        """Initialize the bot client and command tree.

        Args:
            intents: The intents to use.
        """
        super().__init__(intents=intents)
        self.tree = discord.app_commands.CommandTree(self)

    async def on_error(self, event_method: str, *args: list[Any], **kwargs: dict[str, Any]) -> None:
        """Log errors that occur in the bot."""
        logger.exception(f"An error occurred in {event_method} with args: {args} and kwargs: {kwargs}")
        with sentry_sdk.push_scope() as scope:
            # Add event details
            scope.set_tag("event_method", event_method)
            scope.set_extra("args", args)
            scope.set_extra("kwargs", kwargs)

            # Add bot state
            scope.set_tag("bot_user_id", self.user.id if self.user else "Unknown")
            scope.set_tag("bot_user_name", str(self.user) if self.user else "Unknown")
            scope.set_tag("bot_latency", self.latency)

            # If specific arguments are available, extract and add details
            if args:
                interaction = next((arg for arg in args if isinstance(arg, discord.Interaction)), None)
                if interaction:
                    scope.set_extra("interaction_id", interaction.id)
                    scope.set_extra("interaction_user", interaction.user.id)
                    scope.set_extra("interaction_user_tag", str(interaction.user))
                    scope.set_extra("interaction_command", interaction.command.name if interaction.command else None)
                    scope.set_extra("interaction_channel", str(interaction.channel))
                    scope.set_extra("interaction_guild", str(interaction.guild) if interaction.guild else None)

                    # Add Sentry tags for interaction details
                    scope.set_tag("interaction_id", interaction.id)
                    scope.set_tag("interaction_user_id", interaction.user.id)
                    scope.set_tag("interaction_user_tag", str(interaction.user))
                    scope.set_tag("interaction_command", interaction.command.name if interaction.command else "None")
                    scope.set_tag("interaction_channel_id", interaction.channel.id if interaction.channel else "None")
                    scope.set_tag("interaction_channel_name", str(interaction.channel))
                    scope.set_tag("interaction_guild_id", interaction.guild.id if interaction.guild else "None")
                    scope.set_tag("interaction_guild_name", str(interaction.guild) if interaction.guild else "None")

            # Add APScheduler context
            scope.set_extra("scheduler_jobs", [job.id for job in scheduler.get_jobs()])

            sentry_sdk.capture_exception()

    async def on_ready(self) -> None:
        """Log when the bot is ready."""
        logger.info(f"Logged in as {self.user} ({self.user.id if self.user else 'Unknown'})")

    async def setup_hook(self) -> None:
        """Setup the bot."""
        scheduler.start()
        scheduler.add_listener(my_listener, EVENT_JOB_MISSED | EVENT_JOB_ERROR)
        jobs: list[Job] = scheduler.get_jobs()
        if not jobs:
            logger.info("No jobs available.")
            return

        logger.info("Jobs available:")
        try:
            for job in jobs:
                msg: str = job.kwargs.get("message", "") if (job.kwargs and isinstance(job.kwargs, dict)) else ""
                time: str = "Paused"
                if hasattr(job, "next_run_time") and job.next_run_time and isinstance(job.next_run_time, datetime.datetime):
                    time = job.next_run_time.strftime("%Y-%m-%d %H:%M:%S")
                logger.info(f"\t{job.id}: {job.name} - {time} - {msg}")

        except (AttributeError, LookupError):
            logger.exception("Failed to loop through jobs")

        await self.tree.sync()


class RemindGroup(discord.app_commands.Group):
    """Base class for the /remind commands."""

    def __init__(self) -> None:
        """Initialize the remind group."""
        super().__init__(name="remind", description="Group for remind commands")
        """Group for remind commands."""

    # /remind add
    @discord.app_commands.command(name="add", description="Add a new reminder")
    async def add(
        self,
        interaction: discord.Interaction,
        message: str,
        time: str,
        channel: discord.TextChannel | None = None,
        user: discord.User | None = None,
        dm_and_current_channel: bool | None = None,
    ) -> None:
        """Add a new reminder.

        Args:
            interaction (discord.Interaction): The interaction object for the command.
            message (str): The content of the reminder.
            time (str): The time of the reminder. (e.g. Friday at 3 PM)
            channel (discord.TextChannel, optional): The channel to send the reminder to. Defaults to current channel.
            user (discord.User, optional): Send reminder as a DM to this user. Defaults to None.
            dm_and_current_channel (bool, optional): Send reminder as a DM to the user and in this channel. Defaults to False.
        """
        await interaction.response.defer()
        return await add_reminder_job(
            interaction=interaction,
            message=message,
            time=time,
            channel=channel,
            user=user,
            dm_and_current_channel=dm_and_current_channel,
        )

    # /remind event
    @discord.app_commands.command(name="event", description="Add a new Discord event.")
    async def add_event(
        self,
        interaction: discord.Interaction,
        message: str,
        event_start: str,
        event_end: str,
        location: str,
        reason: str | None = None,
    ) -> None:
        """Add a new reminder.

        Args:
            interaction (discord.Interaction): The interaction object for the command.
            message (str): The description of the scheduled event.
            event_start (str): The scheduled start time of the scheduled event. Will get parsed.
            event_end (str, optional): The scheduled end time of the scheduled event. Will get parsed.
            reason (str, optional): The reason for creating this scheduled event. Shows up on the audit log.
            location (str, optional): The location of the scheduled event.
        """
        await interaction.response.defer()
        return await add_discord_event(
            interaction=interaction,
            message=message,
            event_start=event_start,
            event_end=event_end,
            location=location,
            reason=reason,
        )

    # /remind list
    @discord.app_commands.command(name="list", description="List, pause, unpause, and remove reminders.")
    async def list(self, interaction: discord.Interaction) -> None:
        """List all reminders with pagination and buttons for deleting and modifying jobs.

        Args:
            interaction(discord.Interaction): The interaction object for the command.
        """
        await interaction.response.defer()
        return await list_reminder_job(
            interaction=interaction,
            scheduler=scheduler,
        )

    # /remind cron
    @discord.app_commands.command(name="cron", description="Create new cron job. Works like UNIX cron.")
    async def cron(
        self,
        interaction: discord.Interaction,
        message: str,
        year: str | None = None,
        month: str | None = None,
        day: str | None = None,
        week: str | None = None,
        day_of_week: str | None = None,
        hour: str | None = None,
        minute: str | None = None,
        second: str | None = None,
        start_date: str | None = None,
        end_date: str | None = None,
        timezone: str | None = None,
        jitter: int | None = None,
        channel: discord.TextChannel | None = None,
        user: discord.User | None = None,
        dm_and_current_channel: bool | None = None,
    ) -> None:
        """Create a new cron job.

        Args that are None will be defaulted to *.

        Args:
            interaction (discord.Interaction): The interaction object for the command.
            message (str): The content of the reminder.
            year (str): 4-digit year. Defaults to *.
            month (str): Month (1-12). Defaults to *.
            day (str): Day of the month (1-31). Defaults to *.
            week (str): ISO Week of the year (1-53). Defaults to *.
            day_of_week (str): Number or name of weekday (0-6 or mon,tue,wed,thu,fri,sat,sun).
            hour (str): Hour (0-23). Defaults to *.
            minute (str): Minute (0-59). Defaults to *.
            second (str): Second (0-59). Defaults to *.
            start_date (str): Earliest possible date/time to trigger on (inclusive). Will get parsed.
            end_date (str): Latest possible date/time to trigger on (inclusive). Will get parsed.
            timezone (str): Time zone to use for the date/time calculations Defaults to scheduler timezone.
            jitter (int, optional): Delay the job execution by jitter seconds at most.
            channel (discord.TextChannel, optional): The channel to send the reminder to. Defaults to current channel.
            user (discord.User, optional): Send reminder as a DM to this user. Defaults to None.
            dm_and_current_channel (bool, optional): If user is provided, send reminder as a DM to the user and in this channel. Defaults to only the user.
        """
        await interaction.response.defer()
        return await cron_reminder_job(
            interaction=interaction,
            scheduler=scheduler,
            message=message,
            year=year,
            month=month,
            day=day,
            week=week,
            day_of_week=day_of_week,
            hour=hour,
            minute=minute,
            second=second,
            start_date=start_date,
            end_date=end_date,
            timezone=timezone,
            jitter=jitter,
            channel=channel,
            user=user,
            dm_and_current_channel=dm_and_current_channel,
        )

    # /remind interval
    @discord.app_commands.command(
        name="interval",
        description="Create a new reminder that triggers based on an interval.",
    )
    async def interval(
        self,
        interaction: discord.Interaction,
        message: str,
        weeks: int = 0,
        days: int = 0,
        hours: int = 0,
        minutes: int = 0,
        seconds: int = 0,
        start_date: str | None = None,
        end_date: str | None = None,
        timezone: str | None = None,
        jitter: int | None = None,
        channel: discord.TextChannel | None = None,
        user: discord.User | None = None,
        dm_and_current_channel: bool | None = None,
    ) -> None:
        """Create a new reminder that triggers based on an interval.

        Args:
            interaction (discord.Interaction): The interaction object for the command.
            message (str): The content of the reminder.
            weeks (int, optional): Number of weeks between each run. Defaults to 0.
            days (int, optional): Number of days between each run. Defaults to 0.
            hours (int, optional): Number of hours between each run. Defaults to 0.
            minutes (int, optional): Number of minutes between each run. Defaults to 0.
            seconds (int, optional): Number of seconds between each run. Defaults to 0.
            start_date (str, optional): Earliest possible date/time to trigger on (inclusive). Will get parsed.
            end_date (str, optional): Latest possible date/time to trigger on (inclusive). Will get parsed.
            timezone (str, optional): Time zone to use for the date/time calculations Defaults to scheduler timezone.
            jitter (int, optional): Delay the job execution by jitter seconds at most.
            channel (discord.TextChannel, optional): The channel to send the reminder to. Defaults to current channel.
            user (discord.User, optional): Send reminder as a DM to this user. Defaults to None.
            dm_and_current_channel (bool, optional): If user is provided, send reminder as a DM to the user and in this channel. Defaults to only the user.
        """
        await interaction.response.defer()
        return await interval_reminder_job(
            interaction=interaction,
            message=message,
            weeks=weeks,
            days=days,
            hours=hours,
            minutes=minutes,
            seconds=seconds,
            start_date=start_date,
            end_date=end_date,
            timezone=timezone,
            jitter=jitter,
            channel=channel,
            user=user,
            dm_and_current_channel=dm_and_current_channel,
        )

    # /remind backup
    @discord.app_commands.command(name="backup", description="Backup all reminders to a file.")
    async def backup(self, interaction: discord.Interaction, all_servers: bool = False) -> None:
        """Backup all reminders to a file.

        Args:
            interaction (discord.Interaction): The interaction object for the command.
            all_servers (bool): Backup all servers or just the current server. Defaults to only the current server.
        """
        await interaction.response.defer()
        return await backup_reminder_job(
            interaction=interaction,
            scheduler=scheduler,
            all_servers=all_servers,
        )

    # /remind restore
    @discord.app_commands.command(name="restore", description="Restore reminders from a file.")
    async def restore(self, interaction: discord.Interaction) -> None:
        """Restore reminders from a file.

        Args:
            interaction (discord.Interaction): The interaction object for the command.
        """
        await interaction.response.defer()
        return await restore_reminder_job(
            bot=bot,
            interaction=interaction,
            scheduler=scheduler,
        )

    # /remind remove
    @discord.app_commands.command(name="remove", description="Remove a reminder")
    async def remove(self, interaction: discord.Interaction, job_id: str) -> None:
        """Remove a scheduled reminder.

        Args:
            interaction (discord.Interaction): The interaction object for the command.
            job_id (str): The identifier of the job to remove.
        """
        await interaction.response.defer()
        return await remove_reminder_job(
            interaction=interaction,
            job_id=job_id,
            scheduler=scheduler,
        )

    # /remind pause
    @discord.app_commands.command(name="pause", description="Pause a reminder")
    async def pause(self, interaction: discord.Interaction, job_id: str) -> None:
        """Pause a scheduled reminder.

        Args:
            interaction (discord.Interaction): The interaction object for the command.
            job_id (str): The identifier of the job to pause.
        """
        await interaction.response.defer()
        return await pause_reminder_job(
            interaction=interaction,
            job_id=job_id,
            scheduler=scheduler,
        )

    # /remind unpause
    @discord.app_commands.command(name="unpause", description="Unpause a reminder")
    async def unpause(self, interaction: discord.Interaction, job_id: str) -> None:
        """Unpause a scheduled reminder.

        Args:
            interaction (discord.Interaction): The interaction object for the command.
            job_id (str): The identifier of the job to unpause.
        """
        await interaction.response.defer()
        return await unpause_reminder(
            interaction=interaction,
            job_id=job_id,
            scheduler=scheduler,
        )


intents: discord.Intents = discord.Intents.default()
intents.guild_scheduled_events = True

bot = RemindBotClient(intents=intents)

# Add the group to the bot
remind_group = RemindGroup()
bot.tree.add_command(remind_group)


def send_webhook(custom_url: str = "", message: str = "") -> None:
    """Send a webhook to Discord.

    Args:
        custom_url: The custom webhook URL to send the message to. If not provided, uses the WEBHOOK_URL environment variable.
        message: The message that will be sent to Discord.
    """
    webhook_url: str = os.getenv("WEBHOOK_URL", default="")
    url: str = custom_url or webhook_url

    logger.info(f"Sending webhook to '{url}' with message: '{message}'")

    if not message:
        logger.error("No message provided.")
        message = "No message provided."

    if not url:
        logger.error("No webhook URL provided.")
        return

    webhook: DiscordWebhook = DiscordWebhook(url=url, content=message, rate_limit_retry=True)
    webhook_response: Response = webhook.execute()

    logger.info(f"Webhook response: {webhook_response}")


async def send_to_discord(channel_id: int, message: str, author_id: int) -> None:
    """Send a message to Discord.

    Args:
        channel_id: The Discord channel ID.
        message: The message.
        author_id: User we should ping.
    """
    logger.info(f"Sending message to channel '{channel_id}' with message: '{message}'")

    channel: GuildChannel | discord.Thread | PrivateChannel | None = bot.get_channel(channel_id)
    if channel is None:
        channel = await bot.fetch_channel(channel_id)

    # Channels we can't send messages to
    if isinstance(channel, discord.ForumChannel | discord.CategoryChannel | PrivateChannel):
        logger.warning(f"We haven't implemented sending messages to this channel type {type(channel)}")
        return

    await channel.send(f"<@{author_id}>\n{message}")


async def send_to_user(user_id: int, guild_id: int, message: str) -> None:
    """Send a message to a user via DM.

    Args:
        user_id: The user ID to send the message to.
        guild_id: The guild ID to get the user from.
        message: The message to send.
    """
    logger.info(f"Sending message to user {user_id} in guild {guild_id}")
    try:
        guild: discord.Guild | None = bot.get_guild(guild_id)
        if guild is None:
            guild = await bot.fetch_guild(guild_id)
    except discord.NotFound:
        logger.exception(f"Guild not found. Current guilds: {bot.guilds}")
        return
    except discord.HTTPException:
        logger.exception(f"Failed to fetch guild {guild_id}")
        return

    try:
        member: discord.Member | None = guild.get_member(user_id)
        if member is None:
            member = await guild.fetch_member(user_id)
    except discord.Forbidden:
        logger.exception(f"We do not have access to the guild. Guild: {guild_id}, User: {user_id}")
        return
    except discord.NotFound:
        logger.exception(f"Member not found. Guild: {guild_id}, User: {user_id}")
        return
    except discord.HTTPException:
        logger.exception(f"Fetching the member failed. Guild: {guild_id}, User: {user_id}")
        return

    try:
        await member.send(message)
    except discord.HTTPException:
        logger.exception(f"Failed to send message '{message}' to user '{user_id}' in guild '{guild_id}'")


if __name__ == "__main__":
    bot_token: str = os.getenv("BOT_TOKEN", default="")
    if not bot_token:
        msg = "Missing bot token. Please set the BOT_TOKEN environment variable. Read the README for more information."
        raise ValueError(msg)

    logger.info("Starting bot.")
    bot.run(bot_token)