elliebot/src/EllieBot/_common/DoAsUserMessage.cs

using MessageType = Discord.MessageType;

namespace EllieBot.Modules.Administration;

public sealed class DoAsUserMessage : IUserMessage
{
    private readonly string _message;
    private IUserMessage _msg;
    private readonly IUser _user;

    public DoAsUserMessage(SocketUserMessage msg, IUser user, string message)
    {
        _msg = msg;
        _user = user;
        _message = message;
    }

    public ulong Id => _msg.Id;

    public DateTimeOffset CreatedAt => _msg.CreatedAt;

    public Task DeleteAsync(RequestOptions? options = null)
    {
        return _msg.DeleteAsync(options);
    }

    public Task AddReactionAsync(IEmote emote, RequestOptions? options = null)
    {
        return _msg.AddReactionAsync(emote, options);
    }

    public Task RemoveReactionAsync(IEmote emote, IUser user, RequestOptions? options = null)
    {
        return _msg.RemoveReactionAsync(emote, user, options);
    }

    public Task RemoveReactionAsync(IEmote emote, ulong userId, RequestOptions? options = null)
    {
        return _msg.RemoveReactionAsync(emote, userId, options);
    }

    public Task RemoveAllReactionsAsync(RequestOptions? options = null)
    {
        return _msg.RemoveAllReactionsAsync(options);
    }

    public Task RemoveAllReactionsForEmoteAsync(IEmote emote, RequestOptions? options = null)
    {
        return _msg.RemoveAllReactionsForEmoteAsync(emote, options);
    }

    public IAsyncEnumerable<IReadOnlyCollection<IUser>> GetReactionUsersAsync(
        IEmote emoji,
        int limit,
        RequestOptions? options = null,
        ReactionType type = ReactionType.Normal)
        => _msg.GetReactionUsersAsync(emoji, limit, options, type);

    public IAsyncEnumerable<IReadOnlyCollection<IUser>> GetReactionUsersAsync(IEmote emoji, int limit,
        RequestOptions? options = null)
    {
        return _msg.GetReactionUsersAsync(emoji, limit, options);
    }

    public MessageType Type => _msg.Type;

    public MessageSource Source => _msg.Source;

    public bool IsTTS => _msg.IsTTS;

    public bool IsPinned => _msg.IsPinned;

    public bool IsSuppressed => _msg.IsSuppressed;

    public bool MentionedEveryone => _msg.MentionedEveryone;

    public string Content => _message;

    public string CleanContent => _msg.CleanContent;

    public DateTimeOffset Timestamp => _msg.Timestamp;

    public DateTimeOffset? EditedTimestamp => _msg.EditedTimestamp;

    public IMessageChannel Channel => _msg.Channel;

    public IUser Author => _user;

    public IThreadChannel Thread => _msg.Thread;

    public IReadOnlyCollection<IAttachment> Attachments => _msg.Attachments;

    public IReadOnlyCollection<IEmbed> Embeds => _msg.Embeds;

    public IReadOnlyCollection<ITag> Tags => _msg.Tags;

    public IReadOnlyCollection<ulong> MentionedChannelIds => _msg.MentionedChannelIds;

    public IReadOnlyCollection<ulong> MentionedRoleIds => _msg.MentionedRoleIds;

    public IReadOnlyCollection<ulong> MentionedUserIds => _msg.MentionedUserIds;

    public MessageActivity Activity => _msg.Activity;

    public MessageApplication Application => _msg.Application;

    public MessageReference Reference => _msg.Reference;

    public IReadOnlyDictionary<IEmote, ReactionMetadata> Reactions => _msg.Reactions;

    public IReadOnlyCollection<IMessageComponent> Components => _msg.Components;

    public IReadOnlyCollection<IStickerItem> Stickers => _msg.Stickers;

    public MessageFlags? Flags => _msg.Flags;

    [Obsolete("Obsolete in favor of InteractionMetadata")]
    public IMessageInteraction Interaction => _msg.Interaction;
    public MessageRoleSubscriptionData RoleSubscriptionData => _msg.RoleSubscriptionData;

    public Task ModifyAsync(Action<MessageProperties> func, RequestOptions? options = null)
    {
        return _msg.ModifyAsync(func, options);
    }

    public Task PinAsync(RequestOptions? options = null)
    {
        return _msg.PinAsync(options);
    }

    public Task UnpinAsync(RequestOptions? options = null)
    {
        return _msg.UnpinAsync(options);
    }

    public Task CrosspostAsync(RequestOptions? options = null)
    {
        return _msg.CrosspostAsync(options);
    }

    public string Resolve(TagHandling userHandling = TagHandling.Name, TagHandling channelHandling = TagHandling.Name,
        TagHandling roleHandling = TagHandling.Name,
        TagHandling everyoneHandling = TagHandling.Ignore, TagHandling emojiHandling = TagHandling.Name)
    {
        return _msg.Resolve(userHandling, channelHandling, roleHandling, everyoneHandling, emojiHandling);
    }

    public MessageResolvedData ResolvedData => _msg.ResolvedData;

    public IUserMessage ReferencedMessage => _msg.ReferencedMessage;

    public IMessageInteractionMetadata InteractionMetadata
        => _msg.InteractionMetadata;
}