interactions.py

# -*- coding: utf-8 -*-

"""
The MIT License (MIT)

Copyright (c) 2021-present mccoderpy

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
"""
from __future__ import annotations

import re
import asyncio
import logging
from typing import (
    Any,
    Dict,
    List,
    Match,
    Optional,
    overload,
    Sequence,
    Set,
    Tuple,
    TYPE_CHECKING,
    Union
)

from typing_extensions import Literal

from . import abc, utils
from .monetization import Entitlement
from .object import Object
from .channel import _channel_factory, DMChannel, TextChannel, ThreadChannel, VoiceChannel, ForumPost, PartialMessageable
from .components import *
from .embeds import Embed
from .enums import (
    ApplicationCommandType,
    ComponentType,
    Locale,
    ChannelType,
    InteractionCallbackType,
    InteractionType,
    MessageType,
    OptionType,
    InteractionContextType,
    AppIntegrationType,
    try_enum
)
from .errors import AlreadyResponded, HTTPException, NotFound, UnknownInteraction
from .file import File
from .flags import MessageFlags
from .guild import Guild
from .http import handle_interaction_message_parameters, handle_message_parameters, HTTPClient
from .member import Member
from .mentions import AllowedMentions
from .message import Attachment, Message
from .permissions import Permissions
from .reaction import Reaction
from .role import Role
from .user import User
from .utils import cached_slot_property, MISSING

if TYPE_CHECKING:
    import datetime
    from .types.interaction import (
        Interaction as InteractionPayload,
        InteractionData as InteractionDataPayload,
        ApplicationCommandInteractionDataOption as ApplicationCommandInteractionDataOptionPayload,
        ResolvedData as ResolvedDataPayload,
        AuthorizingIntegrationOwners as AuthorizingIntegrationOwnersPayload
    )
    from .types.message import Message as MessagePayload
    from .state import ConnectionState
    from .components import BaseSelect
    from .application_commands import SlashCommandOptionChoice, SlashCommand, MessageCommand, UserCommand


log = logging.getLogger(__name__)

__all__ = (
    'EphemeralMessage',
    'BaseInteraction',
    'ApplicationCommandInteraction',
    'ComponentInteraction',
    'AutocompleteInteraction',
    'ModalSubmitInteraction',
    'option_str',
    'option_float',
    'option_int',
)


class EphemeralMessage:
    """
    Like a normal :class:`~discord.Message` but with a modified :meth:`edit` method and without
    :meth:`~discord.Message.delete` method.
    """
    # This class will be removed in the future when we switched to use the WebhookMessage model instead
    def __init__(self, *, state, channel, data, interaction):
        self._state: ConnectionState = state
        self.__interaction__: BaseInteraction = interaction
        self.id = int(data.get('id', 0))
        self.webhook_id = utils._get_as_snowflake(data, 'webhook_id')
        self.channel_id = utils._get_as_snowflake(data, 'channel_id')
        self.channel = channel
        self._update(data)

    def _update(self, data):
        self.application = data.get('application')
        self.activity = data.get('activity')
        self._edited_timestamp = utils.parse_time(data['edited_timestamp'])
        self.type = try_enum(MessageType, data['type'])
        self._thread = data.get('thread', None)
        self.pinned = data['pinned']
        self.mention_everyone = data['mention_everyone']

        for handler in (
                'tts',
                'content',
                'embeds',
                'author',
                'member',
                'mentions',
                'mention_roles',
                'flags',
                'components',
                'interaction',
                'attachments',
                'reactions'
        ):
            try:
                getattr(self, '_handle_%s' % handler)(data[handler])
            except KeyError:
                if not hasattr(self, handler):
                    setattr(
                        self,
                        handler,
                        None if handler not in {
                            'embeds',
                            'mentions',
                            'mentioned_roles',
                            'attachments',
                            'reactions',
                            'components'
                        } else []
                    )  # bad solution for now but works, will be removed anyway when rewrite the existing webhook system
        return self

    def _handle_flags(self, value):
        self.flags = MessageFlags._from_value(value)

    def _handle_application(self, value):
        self.application = value

    def _handle_activity(self, value):
        self.activity = value

    def _handle_mention_everyone(self, value):
        self.mention_everyone = value

    def _handle_tts(self, value):
        self.tts = value

    def _handle_type(self, value):
        self.type = try_enum(MessageType, value)

    def _handle_content(self, value):
        self.content = value

    def _handle_attachments(self, value):
        self.attachments = [Attachment(data=a, state=self._state) for a in value]

    def _handle_embeds(self, value):
        self.embeds = [Embed.from_dict(data) for data in value]

    def _handle_interaction(self, value):
        self.interaction = value

    def _handle_components(self, value):
        self.components = [ActionRow.from_dict(data) for data in value]

    def _handle_reactions(self, value):
        self.reactions = [Reaction(message=self, data=d) for d in value]

    def _handle_nonce(self, value):
        self.nonce = value

    def _handle_author(self, author):
        self.author = self._state.store_user(author)
        if isinstance(self.guild, Guild):
            found = self.guild.get_member(self.author.id)
            if found is not None:
                self.author = found

    def _handle_member(self, member):
        # The gateway now gives us full Member objects sometimes with the following keys
        # deaf, mute, joined_at, roles
        # For the sake of performance I'm going to assume that the only
        # field that needs *updating* would be the joined_at field.
        # If there is no Member object (for some strange reason), then we can upgrade
        # ourselves to a more "partial" member object.
        author = self.author
        try:
            # Update member reference
            author._update_from_message(member)
        except AttributeError:
            # It's a user here
            # TODO: consider adding to cache here
            self.author = Member._from_message(message=self, data=member)

    def _handle_mentions(self, mentions):
        self.mentions = r = []
        guild = self.guild
        state = self._state
        if not isinstance(guild, Guild):
            self.mentions = [state.store_user(m) for m in mentions]
            return

        for mention in filter(None, mentions):
            id_search = int(mention['id'])
            member = guild.get_member(id_search)
            if member is not None:
                r.append(member)
            else:
                r.append(Member._try_upgrade(data=mention, guild=guild, state=state))

    def _handle_mention_roles(self, role_mentions):
        self.role_mentions = []
        if isinstance(self.guild, Guild):
            for role_id in map(int, role_mentions):
                role = self.guild.get_role(role_id)
                if role is not None:
                    self.role_mentions.append(role)

    @utils.cached_slot_property('_cs_guild')
    def guild(self):
        """Optional[:class:`Guild`]: The guild that the message belongs to, if applicable."""
        return getattr(self.channel, 'guild', None)

    def __repr__(self):
        return '<EphemeralMessage id={0.id} channel={0.channel!r} type={0.type!r} author={0.author!r} flags={0.flags!r}>'.format(
            self)

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.id == other.id

    @property
    def all_components(self):
        """Union[:class:`Button`, :ref:`Select <select-like-objects>`]:
        Yields all buttons and selects that are contained in the message"""
        for action_row in self.components:
            yield from action_row

    @property
    def all_buttons(self):
        """Returns all :class:`Button`'s that are contained in the message"""
        for action_row in self.components:
            for component in action_row:
                yield component

    @property
    def all_select_menus(self):
        """Returns all :ref:`Select <select-like-objects>`'s that are contained in the message"""
        for action_row in self.components:
            for component in action_row:
                if int(component.type) in {3, 5, 6, 7, 8}:
                    yield component

    async def edit(
            self,
            *,
            content: Any = MISSING,
            embed: Optional[Embed] = MISSING,
            embeds: Sequence[Embed] = MISSING,
            components: List[Union[ActionRow, List[Union[Button, BaseSelect]]]] = MISSING,
            attachments: Sequence[Union[Attachment, File]] = MISSING,
            keep_existing_attachments: bool = False,
            allowed_mentions: Optional[AllowedMentions] = MISSING,
            suppress_embeds: bool = False,
            delete_after: Optional[float] = None
    ) -> Union[Message, EphemeralMessage]:
        """|coro|

        Edits the message.

        Parameters
        -----------
        content: Optional[:class:`str`]
            The new content to replace the message with.
            Could be ``None`` to remove the content.
        embed: Optional[:class:`Embed`]
            The new embed to replace the original with.
            Could be ``None`` to remove all embeds.
        embeds: Optional[List[:class:`Embed`]]
            A list containing up to 10 embeds to send.
            If ``None`` or empty, all embeds will be removed.
            
            If passed, ``embed`` does also count towards the limit of 10 embeds.
        components: List[Union[:class:`~discord.ActionRow`, List[Union[:class:`~discord.Button`, :ref:`Select <select-like-objects>`]]]]
            A list of up to five :class:`~discord.ActionRow`s or :class:`list`,
            each containing up to five :class:`~discord.Button` or one :ref:`Select <select-like-objects>` like object.
        attachments: List[Union[:class:`Attachment`, :class:`File`]]
            A list containing previous attachments to keep as well as new files to upload.
            You can use ``keep_existing_attachments`` to auto-add the existing attachments to the list.
            If  an empty list (``[]``) is passed, all attachment will be removed.

            .. note::

                New files will always appear under existing ones.

        keep_existing_attachments: :class:`bool`
            Whether to auto-add existing attachments to ``attachments``, default :obj:`False`.

            .. note::

                Only needed when ``attachments`` are passed, otherwise will be ignored.

        suppress_embeds: :class:`bool`
            Whether to suppress embeds for the message. If ``True`` this will remove all embeds from the message.
            If `´False`` it adds them back.
        delete_after: :class:`float`
            If provided, the number of seconds to wait in the background
            before deleting the response we just edited. If the deletion fails,
            then it is silently ignored.
        allowed_mentions: Optional[:class:`~discord.AllowedMentions`]
            Controls the mentions being processed in this message. If this is
            passed, then the object is merged with :attr:`~discord.Client.allowed_mentions`.
            The merging behaviour only overrides attributes that have been explicitly passed
            to the object, otherwise it uses the attributes set in :attr:`~discord.Client.allowed_mentions`.
            If no object is passed at all then the defaults given by :attr:`~discord.Client.allowed_mentions`
            are used instead.


        """

        if suppress_embeds:
            flags = MessageFlags._from_value(self.flags.value)
            flags.suppress_embeds = True
        else:
            flags = MISSING

        if keep_existing_attachments:
            if attachments is not MISSING:
                attachments = [*self.attachments, *attachments]

        state = self._state
        interaction = self.__interaction__

        if not self.channel:
            self.channel = self._state.add_dm_channel(data=await state.http.get_channel(self.channel_id))

        is_original_response = interaction.callback_message and self.id == interaction.callback_message.id

        params = handle_message_parameters(
            content=content,
            flags=flags,
            embed=embed,
            embeds=embeds,
            attachments=attachments,
            components=components,
            allowed_mentions=allowed_mentions,
            previous_allowed_mentions=state.allowed_mentions
        )

        if is_original_response:
            method = state.http.edit_original_interaction_response(
                token=interaction._token,
                application_id=interaction._application_id,
                params=params
            )
        else:
            method = state.http.edit_followup(
                token=interaction._token,
                application_id=interaction._application_id,
                message_id=self.id,
                params=params
            )

        with params:
            data = await method

        if not isinstance(data, dict):
            if is_original_response:
                return await interaction.get_original_callback()
            else:
                data = await state.http.get_followup_message(
                    token=interaction._token,
                    application_id=interaction._application_id,
                    message_id=self.id,
                )
        self._update(data)
        if delete_after:
            import warnings
            warnings.warn("You can\'t delete a ephemeral message manual.")
        return self

    async def delete(self, *, delay: Optional[float] = None) -> None:
        """|coro|

        Deletes the message.

        .. note::
            This can only be used while the interaction token is valid. So within 15 minutes after the interaction.

        Parameters
        -----------
        delay: Optional[:class:`float`]
            If provided, the number of seconds to wait in the background
            before deleting the message. If the deletion fails then it is silently ignored.

        Raises
        ------
        NotFound
            The message was deleted already or the interaction token expired
        HTTPException
            Deleting the message failed.
        """
        interaction = self.__interaction__
        is_original_response = interaction.callback_message and self.id == interaction.callback_message.id
        if delay is not None:
            async def delete():
                await asyncio.sleep(delay)
                try:
                    await self._state.http.delete_interaction_response(
                        interaction._token,
                        interaction._application_id,
                        message_id=self.id if not is_original_response else '@original'
                    )
                except HTTPException:
                    pass

            asyncio.ensure_future(delete(), loop=self._state.loop)
        else:
            await self._state.http.delete_interaction_response(
                interaction._token,
                interaction._application_id,
                message_id=self.id if not is_original_response else '@original'
            )


class AuthorizingIntegrationOwners:
    """
    Includes details about the authorizing user or server (guild) for the installation(s) relevant to the interaction.
    For apps installed to a user, it can be used to tell the difference between the authorizing user and the user
    that triggered an interaction (like a message component).

    An attribute will only be present if the following are true:

    - The app has been authorized to the installation context (see :class:`~discord.AppIntegrationType`)
    - The interaction is supported in the source :class:`~discord.InteractionContextType` for the installation context
      corresponding to the key
    - And for command invocations, the command must be supported in the installation context (using `integration_types`)

    The values depend on the source of the interaction:

    If the key is :attr:`~discord.AppIntegrationType.guild_install`, the value depends on the source of the interaction:
        The value will be the guild ID if the interaction is triggered from a server
        The value will be "0" if the interaction is triggered from a DM with the app's bot user
    If the key is :attr:`~discord.AppIntegrationType.user_install`, the value will be the ID of the authorizing user
    """
    def __init__(self, data: AuthorizingIntegrationOwnersPayload, state: ConnectionState):
        self._data = data

    def __repr__(self):
        return f'<AuthorizingIntegrationOwners {self._data!r}>'


class BaseInteraction:
    """
    The Base-Class for a discord-interaction like clicking a :class:`~discord.Button`,
    select (an) option(s) of :class:`~discord.SelectMenu` or using an application-command in discord
    For more general information's about Interactions visit the Documentation of the
    `Discord-API <https://discord.com/developers/docs/interactions/receiving-and-responding#interaction-object>`_

    The following attributes are always available:

    Attributes
    ------------
    id: :class:`int`
        The id of the interaction.
    type: :class:`~discord.InteractionType`
        The type of the interaction.
    user_id: :class:`int`
        The id of the user who triggered the interaction.
    channel_id: :class:`int`
        The id of the channel where the interaction was triggered.
    entitlements: Optional[List[:class:`~discord.Entitlement`]]
        For :ddocs:`monetized apps <monetization/overview>` entitlements of the user who triggered the interaction
        and optionally, if any.

        This is available for all interaction types.
    context: Optional[:class:`~discord.InteractionContextType`]
        The context of the interaction, if any.
    authorizing_guild_id: Optional[:class:`int`]
        Depending on the context of the interaction, the guild ID where the app integration was authorized to:
            - The value will be the guild ID if the interaction is triggered from a server
            - The value will be `0` if the interaction is triggered from a DM with the app's bot user

        .. seealso::
            :attr:`.authorizing_guild`
    authorizing_user_id: Optional[:class:`int`]
        The ID of the user the app integration is authorized to, if any.

        .. seealso::
            :attr:`.authorizing_user`
    data: :class:`~discord.InteractionData`
        Some internal needed metadata for the interaction, depending on the type.
    author_locale: Optional[:class:`~discord.Locale`]
        The locale of the user who triggered the interaction.
    guild_locale: Optional[:class:`~discord.Locale`]
        The locale of the guild where the interaction was triggered.
    guild_id: Optional[:class:`int`]
        The id of the guild where the interaction was triggered, if any.
    app_permissions: Optional[:class:`~discord.Permissions`]
        The permissions of the bot in the channel where the interaction was triggered, if it was in a guild.

        This is similar to `interaction.channel.permissions_for(interaction.guild.me)` but calculated on discord side.
    author_permissions: Optional[:class:`~discord.Permissions`]
        The author's permissions in the channel where the interaction was triggered, if it was in a guild.

        This is similar to `interaction.channel.permissions_for(interaction.author)`, but calculated on discord side.
    """
    if TYPE_CHECKING:
        type: InteractionType
        id: int
        context: Optional[InteractionContextType]  # Why is this optional?
        authorizing_guild_id: Optional[int]
        authorizing_user_id: Optional[int]
        guild_id: Optional[int]
        channel_id: int
        user_id: int
        user: User
        author_locale: Locale
        entitlements: Set[Entitlement]
        app_permissions: Optional[Permissions]
        author_permissions: Optional[Permissions]
        member: Optional[Member]
        guild_locale: Optional[Locale]
        data: Optional[InteractionData]
        message: Optional[Union[Message, EphemeralMessage]]
        cached_message: Optional[Union[Message, EphemeralMessage]]
        message_id: Optional[int]

    def __init__(self, state: ConnectionState, data: InteractionPayload) -> None:
        self._state: ConnectionState = state
        self._http: HTTPClient = state.http
        self._application_id = int(data.get('application_id'))
        self._token = data['token']
        self.type = InteractionType.try_value(data['type'])
        self.id = int(data['id'])
        self.context = try_enum(data.get('context'), InteractionContextType)
        authorizing_integration_owners = data.get('authorizing_integration_owners')
        self.authorizing_guild_id = utils._get_as_snowflake(authorizing_integration_owners, '0')
        self.authorizing_user_id = utils._get_as_snowflake(authorizing_integration_owners, '1')
        self.guild_id = guild_id = utils._get_as_snowflake(data, 'guild_id')
        self.entitlements = {Entitlement(data=e, state=state) for e in data.get('entitlements', [])}
        channel_data = data.get('channel', {})
        self.channel_id = channel_id = int(data.get('channel_id', channel_data.get('id', 0)))

        guild = self.guild or Object(id=guild_id) if guild_id else None  # I'm not sure if we need the Object thing here
        channel, member = (None, None)

        if guild:
            member_data = data.get('member')
            user_data = member_data.get('user')
            self.user_id = user_id = int(user_data['id'])

            if isinstance(guild, Guild):
                channel = guild.get_channel(self.channel_id)
                member = guild.get_member(user_id)

            self.member = member or Member(state=state, data=member_data, guild=guild)
            # consider updating the member here
            self.author_permissions = Permissions(int(member_data.get('permissions', 0)))
            self.guild_locale = try_enum(Locale, data.get('guild_locale'))
        else:
            channel = state._get_private_channel(channel_id)
            user_data = data.get('user')
            self.app_permissions = None
            self.author_permissions = None
            self.member = None
            self.guild_locale = None
            self.user_id = int(user_data['id'])

        self.user = state.store_user(user_data)

        if not channel:
            factory, ch_type = _channel_factory(channel_data['type'])
            if ch_type in (ChannelType.group, ChannelType.private):
                # In my tests the required fields for those channels where always present
                channel = factory(me=state.user, data=channel_data, state=state)
            else:
                channel = PartialMessageable(
                    state=state,
                    id=self.channel_id,
                    guild_id=self.guild_id,
                    type=ch_type,
                    partial_data=channel_data
                )

        self._channel = channel

        message_data: MessagePayload = data.get('message')
        if message_data is not None:
            if MessageFlags._from_value(message_data['flags']).ephemeral:
                self.message = EphemeralMessage(state=state, channel=channel, data=message_data, interaction=self)
            else:
                self.message = Message(state=state, channel=channel, data=message_data)
            # Remove this on release, it's unnecessary as we always get the full message (except reactions for components)
            self.cached_message = self.message and state._get_message(self.message.id)
            self.message_id = int(message_data['id'])
        else:
            self.message = None
            self.cached_message = None
            self.message_id = None

        interaction_data: InteractionDataPayload = data.get('data')
        if interaction_data is not None:
            self.data = InteractionData(data=interaction_data, state=state, guild=self.guild, channel_id=self.channel_id)
        else:
            self.data = None

        self.author_locale = try_enum(Locale, data['locale'])
        self.deferred: bool = False
        self.deferred_hidden: bool = False
        self.deferred_modal: bool = False
        self._command = None
        self._callback_message: Optional[Union[Message, EphemeralMessage]] = None
        self.messages: Dict[Union[str, int], Union[Message, EphemeralMessage]] = {}

    def __repr__(self) -> str:
        """Represents a :class:`~discord.BaseInteraction` object."""
        return f'<{self.__class__.__name__} {", ".join([f"{k}={v}" for k, v in self.__dict__.items() if k[0] != "_"])}>'

    @property
    def authorizing_guild(self) -> Optional[Union[Guild, Object]]:
        """Optional[Union[:class:`~discord.Guild`, :class:`~discord.Object`]]: The guild where the app integration was
            authorized to. If not cached this will return an :class:`~discord.Object` with the ID set to the guild ID.


        .. note::
            This is only available for interactions that were triggered in a guild, in a DM this will be ``None``.
        """
        if self.authorizing_guild_id:
            return self._state._get_guild(self.authorizing_guild_id) or Object(id=self.authorizing_guild_id)
        return None

    @property
    def authorizing_user(self) -> Optional[User]:
        """Optional[Union[:class:`~discord.User`, :class:`~discord.Object`]]: The user the app integration is
            authorized to, if any.
            If not cached this will return an :class:`~discord.Object` with the ID set to the user ID.
        """
        if self.authorizing_user_id:
            return self._state.get_user(self.authorizing_user_id) or Object(id=self.authorizing_user_id)
        return None

    @property
    def callback_message(self) -> Optional[Union[Message, EphemeralMessage]]:
        """
        Optional[Union[:class:`Message`, :class:`EphemeralMessage`]: The initial interaction response message, if any.
        """
        return self._callback_message
    
    @callback_message.setter
    def callback_message(self, value: Optional[Union[Message, EphemeralMessage]]) -> None:
        self._callback_message = value
        if value:
            self.messages['@original'] = value

    async def _defer(
            self,
            response_type: Optional[InteractionCallbackType] = InteractionCallbackType.deferred_update_msg,
            hidden: Optional[bool] = False
    ) -> Optional[Union[Message, EphemeralMessage]]:
        """
        |coro|

        'Defers' the response.

        If :attr:`response_type` is `InteractionCallbackType.deferred_msg_with_source` it shows a loading state to the user.

        response_type: Optional[:class:`InteractionCallbackType`]
            The type to response with, aiter :class:`InteractionCallbackType.deferred_msg_with_source` or :class:`InteractionCallbackType.deferred_update_msg` (e.g. 5 or 6)

        hidden: Optional[:class:`bool`]
            Whether to defer ephemerally(only the :attr:`author` of the interaction can see the message)

            .. note::
                Only for :class:`InteractionCallbackType.deferred_msg_with_source`.

        .. important::
            If you don't respond with a message using :meth:`respond`
            or edit the original message using :meth:`edit` within less than 3 seconds,
            discord will indicate that the interaction failed and the interaction-token will be invalidated.
            To provide this us this method

        .. note::
            A Token will be Valid for 15 Minutes, so you could edit the original :attr:`message` with :meth:`edit`,
             :meth:`respond` or doing anything other with this interaction for 15 minutes.
            After that time you have to edit the original message with the Methode :meth:`edit` of the :attr:`message`
             and send new messages with the :meth:`send` Methode of :attr:`channel`
            (you could not do this hidden as it isn't a response anymore).
        """
        if isinstance(response_type, int):
            response_type = InteractionCallbackType.from_value(response_type)
        if self.deferred:
            raise AlreadyResponded(self.id)
        base = {"type": int(response_type), "data": {'flags': 64 if hidden else None}}
        try:
            data = await self._http.post_initial_response(
                data=base,
                token=self._token,
                interaction_id=self.id
            )
        except NotFound:
            raise UnknownInteraction(self.id)
        else:
            self.deferred = True
            if hidden is True:
                self.deferred_hidden = True
            if not data and response_type.msg_with_source or response_type.deferred_msg_with_source:
                msg = self.callback_message = await self.get_original_callback()
                return msg

    @utils.deprecated("Respond normal using ButtonType.premium instead")
    async def _premium_required(self) -> None:
        """|coro|
        Respond with an upgrade button, only available for apps
        with :ddocs:`monetized apps <monetization/overview>` enabled.
        """
        await self._state.http.post_initial_response(
            self.id,
            self._token,
            data={'type': InteractionCallbackType.premium_required.value}
        )

    async def _respond_with_launch_activity(self) -> None:
        """|coro|
        Respond by launching the activity associated with the application.
        Only available for apps with :ddocs:`Activities <activities/overview>` enabled.
        """
        await self._state.http.post_initial_response(
            self.id,
            self._token,
            data={'type': InteractionCallbackType.launch_activity.value}
        )

    async def edit(
            self,
            *,
            content: Any = MISSING,
            embed: Optional[Embed] = MISSING,
            embeds: Sequence[Embed] = MISSING,
            components: List[Union[ActionRow, List[Union[Button, BaseSelect]]]] = MISSING,
            attachments: Sequence[Union[Attachment, File]] = MISSING,
            keep_existing_attachments: bool = False,
            delete_after: Optional[float] = None,
            allowed_mentions: Optional[AllowedMentions] = MISSING,
            suppress_embeds: Optional[bool] = False
    ) -> Union[Message, EphemeralMessage]:
        """|coro|

        Responds to the interaction by editing the original (:attr:`~ComponentInteraction.message`)
        or :attr:`callback_message`, depending on the :attr:`~BaseInteraction.type`.

        Parameters
        -----------
        content: Optional[:class:`str`]
            The new content to replace the message with.
            Could be ``None`` to remove the content.
        embed: Optional[:class:`Embed`]
            The new embed to replace the original with.
            Could be ``None`` to remove all embeds.
        embeds: Optional[List[:class:`Embed`]]
            A list containing up to 10 embeds to send.
            If ``None`` or empty, all embeds will be removed.
            
            If passed, ``embed`` does also count towards the limit of 10 embeds.
        components: List[Union[:class:`~discord.ActionRow`, List[Union[:class:`~discord.Button`, :ref:`Select <select-like-objects>`]]]]
            A list of up to five :class:`~discord.ActionRow` or :class:`list`,
            each containing up to five :class:`~discord.Button` or one :ref:`Select <select-like-objects>` like object.
        attachments: List[Union[:class:`Attachment`, :class:`File`]]
            A list containing previous attachments to keep as well as new files to upload.
            You can use ``keep_existing_attachments`` to auto-add the existing attachments to the list.
            If ``None`` or empty, all attachments will be removed.

            .. note::

                New files will always appear under existing ones.

        keep_existing_attachments: :class:`bool`
            Whether to auto-add existing attachments to ``attachments``, default :obj:`False`.
            
            .. note::

                Only needed when ``attachments`` are passed, otherwise will be ignored.

        suppress_embeds: :class:`bool`
            Whether to suppress embeds for the message. This removes
            all the embeds if set to ``True``. If set to ``False``
            this brings the embeds back if they were suppressed.
        delete_after: Optional[:class:`float`]
            If provided, the number of seconds to wait in the background
            before deleting the response we just edited. If the deletion fails,
            then it is silently ignored.
        allowed_mentions: Optional[:class:`~discord.AllowedMentions`]
            Controls the mentions being processed in this message. If this is
            passed, then the object is merged with :attr:`~discord.Client.allowed_mentions`.
            The merging behaviour only overrides attributes that have been explicitly passed
            to the object, otherwise it uses the attributes set in :attr:`~discord.Client.allowed_mentions`.
            If no object is passed at all then the defaults given by :attr:`~discord.Client.allowed_mentions`
            are used instead.
        
        Raises
        -------
        TypeError
            The interaction was already responded to with a modal,
            or it is an application-command that was not responded to.
        NotFound:
            The interaction is expired.
        HTTPException
            Editing the message failed.
        
        Returns
        --------
        Union[:class:`~discord.Message`, :class:`~discord.EphemeralMessage`]
            The edited message.
        """
        if self.deferred_modal:
            if self.type.Component:
                return await self.message.edit(
                    content=content,
                    embed=embed,
                    embeds=embeds,
                    components=components,
                    attachments=attachments,
                    keep_existing_attachments=keep_existing_attachments,
                    allowed_mentions=allowed_mentions,
                    delete_after=delete_after,
                    suppress_embeds=suppress_embeds
                )
            else:
                raise TypeError('You can\'t edit the message as it does not exist when using `respond_with_modal`.')

        response_type = MISSING

        if not self.deferred:
            if self.type.ApplicationCommand:
                raise TypeError('You need to send a response first before you can edit it')
            else:
                response_type = InteractionCallbackType.update_msg

        m = self.callback_message if self.type.ApplicationCommand else self.message
        
        if suppress_embeds is not MISSING:
            flags = MessageFlags._from_value(m.flags.value) if m else MessageFlags._from_value(0)
            flags.suppress_embeds = suppress_embeds
        else:
            flags = MISSING

        state = self._state
        if not self.channel:
            ch = await self._http.get_channel(self.channel_id)
            self.channel = _channel_factory(ch['type'])[0](state=state, data=ch)

        if response_type is MISSING:
            params = handle_message_parameters(
                content=content,
                flags=flags,
                embed=embed,
                embeds=embeds,
                attachments=attachments,
                components=components,
                allowed_mentions=allowed_mentions,
                previous_allowed_mentions=state.allowed_mentions
            )
            method = state.http.edit_original_interaction_response(
                token=self._token,
                application_id=self._application_id,
                params=params
            )
        else:
            params = handle_interaction_message_parameters(
                type=response_type,
                content=content,
                flags=flags,
                embed=embed,
                attachments=attachments,
                components=components,
                allowed_mentions=allowed_mentions,
                previous_allowed_mentions=state.allowed_mentions
            )
            method = state.http.send_interaction_response(
                interaction_id=self.id,
                token=self._token,
                params=params
            )

        with params:
            data = await method

        if not isinstance(data, dict):
            msg = await self.get_original_callback()
        else:
            if m is not None:
                msg = m._update(data)
            else:
                if MessageFlags._from_value(data['flags']).ephemeral:
                    msg = EphemeralMessage(state=self._state, data=data, channel=self.channel, interaction=self)
                else:
                    msg = Message(state=self._state, channel=self.channel, data=data)
        if not self.deferred:
            self.callback_message = msg
        is_hidden = msg.flags.ephemeral

        if is_hidden:
            self.deferred_hidden = True
        self.deferred = True
        
        if delete_after is not None:
            await msg.delete(delay=delete_after)
        
        return msg

    async def respond(
            self,
            content: str = None, *,
            tts: bool = False,
            embed: Optional[Embed] = None,
            embeds: Optional[List[Embed]] = None,
            components: Optional[List[Union[ActionRow, List[Union[Button, BaseSelect]]]]] = None,
            file: Optional[File] = None,
            files: Optional[List[File]] = None,
            delete_after: Optional[float] = None,
            allowed_mentions: Optional[AllowedMentions] = None,
            suppress_embeds: bool = False,
            suppress_notifications: bool = False,
            hidden: bool = False
    ) -> Union[Message, EphemeralMessage]:
        """|coro|

        Responds to an interaction by sending a message.

        Parameters
        ------------
        content: :class:`str`
            The content of the message to send.
        tts: :class:`bool`
            Indicates if the message should be sent using text-to-speech.
        embed: :class:`~discord.Embed`
            The rich embed for the content.
        embeds: List[:class:`~discord.Embed`]
            A list containing up to 10 embeds.
            
            If passed, ``embed`` also counts towards the limit of 10.
        components: List[Union[:class:`~discord.ActionRow`, List[Union[:class:`~discord.Button`, :ref:`Select <select-like-objects>`]]]]
            A list of up to five :class:`~discord.ActionRow`s/:class:`list`s.
            Each containing up to five :class:`~discord.Button` or one :ref:`Select <select-like-objects>` like object.
        file: :class:`~discord.File`
            The file to upload.
        files: List[:class:`~discord.File`]
            A :class:`list` of files to upload. Must be a maximum of 10.
        suppress_embeds: :class:`bool`
            Whether to suppress embeds for the message.
        suppress_notifications: :class:`bool`
            Whether to suppress desktop- & push-notifications for the post starter-message.
        delete_after: :class:`float`
            If provided, the number of seconds to wait in the background
            before deleting the response we just sent. If the deletion fails,
            then it is silently ignored.
        allowed_mentions: :class:`~discord.AllowedMentions`
            Controls the mentions being processed in this message. If this is
            passed, then the object is merged with :attr:`~discord.Client.allowed_mentions`.
            The merging behaviour only overrides attributes that have been explicitly passed
            to the object, otherwise it uses the attributes set in :attr:`~discord.Client.allowed_mentions`.
            If no object is passed at all then the defaults given by :attr:`~discord.Client.allowed_mentions`
            are used instead.
        hidden: Optional[:class:`bool`]
            If :obj:`True` the message will be only visible for the performer of the interaction (e.g. :attr:`.author`).
        
        Raises
        -------