goober/assets/cogs/fireboard.py

import asyncio
import random

import asqlite
import discord
import discord.ext
import discord.ext.commands
from discord import Color, app_commands
from discord.ext import commands
from discord.ui import View


class Fireboard(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.locked_messages = []
        self.disabled = False
        
        # Check if the bot has the fireboard_pool attribute
        if not hasattr(bot, 'fireboard_pool') or bot.fireboard_pool is None:
            print("Warning: Bot does not have fireboard_pool initialized. Fireboard functionality will be disabled.")
            self.disabled = True
            return
            
        self.fireboard_pool: asqlite.Pool = bot.fireboard_pool
        self.bot.loop.create_task(self.setup())

    # SQL Setup
    async def setup(self):
        async with self.fireboard_pool.acquire() as sql:
            if (
                await sql.fetchone(
                    "SELECT name FROM sqlite_master WHERE type='table' AND name='fireMessages';"
                )
                is None
            ):
                # Fire Messages - messages that are active on the fireboard
                await sql.execute(
                    "CREATE TABLE fireMessages (serverID int, msgID int, boardMsgID int, reactionAmount int)"
                )

            if (
                await sql.fetchone(
                    "SELECT name FROM sqlite_master WHERE type='table' AND name='fireSettings';"
                )
                is None
            ):
                # Fire Settings - server properties for fireboard
                await sql.execute(
                    "CREATE TABLE fireSettings (serverID int, reactionAmount int, emoji text, channelID int, ignoreBots int)"
                )

            if (
                await sql.fetchone(
                    "SELECT name FROM sqlite_master WHERE type='table' AND name='fireChannelBlacklist';"
                )
                is None
            ):
                # Fire Channel Blacklist - blacklisted channels
                await sql.execute(
                    "CREATE TABLE fireChannelBlacklist (serverID int, channelID int)"
                )

            if (
                await sql.fetchone(
                    "SELECT name FROM sqlite_master WHERE type='table' AND name='fireRoleBlacklist';"
                )
                is None
            ):
                # Fire Role Blacklist - blacklisted roles
                await sql.execute(
                    "CREATE TABLE fireRoleBlacklist (serverID int, roleID int)"
                )

            await sql.commit()

        await self.refresh_fire_lists()

    # List refresh function
    async def refresh_fire_lists(self):
        async with self.fireboard_pool.acquire() as sql:
            self.fire_messages = await sql.fetchall("SELECT * FROM fireMessages")
            self.fire_settings = await sql.fetchall("SELECT * FROM fireSettings")
            self.fire_channel_blacklist = await sql.fetchall(
                "SELECT * FROM fireChannelBlacklist"
            )
            self.fire_role_blacklist = await sql.fetchall(
                "SELECT * FROM fireRoleBlacklist"
            )

    # Listen for reactions
    @commands.Cog.listener()
    async def on_raw_reaction_add(self, payload: discord.RawReactionActionEvent):
        self.bot: discord.ext.commands.Bot

        # Stop if this is a DM
        if payload.guild_id is None:
            return

        queued = False

        # Lock system
        if payload.message_id in self.locked_messages:
            queued = True

            while payload.message_id in self.locked_messages:
                await asyncio.sleep(0.5)

        self.locked_messages.append(payload.message_id)

        try:
            fetched = False

            # Find server config
            for server in self.fire_settings:
                if server[0] == payload.guild_id:
                    react_minimum = server[1]
                    emoji = server[2]
                    channel_id = server[3]
                    ignore_bots = True if int(server[4]) == 1 else False

                    fetched = True

            # Stop if server has no config (fireboard isn't enabled)
            if not fetched:
                return

            # Stop if message is by Titanium
            if payload.message_author_id == self.bot.user.id:
                return

            # Stop if emoji doesn't match
            if str(payload.emoji) != emoji:
                return

            # --- Edit board message if it already exists ---
            if payload.message_id in [message[1] for message in self.fire_messages]:
                message = [
                    message
                    for message in self.fire_messages
                    if message[1] == payload.message_id
                ][0]

                # Only fetch updated reaction count if I have queued or reaction amount is undefined
                if queued or message[3] is None:
                    # Fetch message and channel
                    try:
                        msg_channel = await self.bot.fetch_channel(payload.channel_id)
                        message = await msg_channel.fetch_message(payload.message_id)
                    except discord.errors.NotFound:
                        return

                    # Stop if not enough reactions
                    for reaction in message.reactions:
                        if str(reaction.emoji) == emoji:
                            react_count = reaction.count
                            break

                    if react_count < react_minimum:
                        return
                else:
                    react_count = None

                async with self.fireboard_pool.acquire() as sql:
                    # Set updated react count
                    if react_count is not None:
                        await sql.execute(
                            "UPDATE fireMessages SET reactionAmount = ? WHERE msgID = ?",
                            (
                                react_count,
                                payload.message_id,
                            ),
                        )
                        await self.refresh_fire_lists()
                    else:
                        await sql.execute(
                            "UPDATE fireMessages SET reactionAmount = reactionAmount + 1 WHERE msgID = ?",
                            (payload.message_id,),
                        )
                        await self.refresh_fire_lists()

                # Get message from message list
                message = [
                    message
                    for message in self.fire_messages
                    if message[1] == payload.message_id
                ][0]

                # Get board message
                board_channel = await self.bot.fetch_channel(channel_id)
                board_message = await board_channel.fetch_message(message[2])

                await board_message.edit(
                    content=f"**{message[3]} {emoji}** | <@{payload.message_author_id}> | <#{payload.channel_id}>",
                    embeds=board_message.embeds,
                )

                return

            # Stop if message is in a blacklisted channel
            if payload.channel_id in [
                channel[1] for channel in self.fire_channel_blacklist
            ]:
                return

            # Stop if message is by a blacklisted role
            guild = await self.bot.fetch_guild(payload.guild_id)
            member = await guild.fetch_member(payload.user_id)

            if any(
                role[1] in [role.id for role in member.roles]
                for role in self.fire_role_blacklist
            ):
                return

            # Fetch message and channel
            try:
                msg_channel = await self.bot.fetch_channel(payload.channel_id)
                message = await msg_channel.fetch_message(payload.message_id)
            except discord.errors.NotFound:
                return

            # Stop if message is by a bot
            if ignore_bots and message.author.bot:
                return

            # Check if this is a thread
            if isinstance(msg_channel, discord.Thread):
                # Check if parent channel is NSFW
                if msg_channel.parent.nsfw:
                    return
            else:
                # Stop if message is in an NSFW channel
                if message.channel.nsfw:
                    return

            # Stop if not enough reactions
            for reaction in message.reactions:
                if str(reaction.emoji) == emoji:
                    react_count = reaction.count
                    break

            if react_count < react_minimum:
                return

            # --- Send message to fireboard ---

            # Create embed
            embed = discord.Embed(description=message.content, color=Color.random())
            embed.set_author(
                name=message.author.name, icon_url=message.author.display_avatar.url
            )
            embed.timestamp = message.created_at

            # Jump to message button
            view = View()
            view.add_item(
                discord.ui.Button(
                    label="Jump to Message",
                    url=message.jump_url,
                    style=discord.ButtonStyle.url,
                )
            )

            embed_list = [embed]

            # Add reply embed
            if message.reference:
                try:
                    reply_message = await msg_channel.fetch_message(
                        message.reference.message_id
                    )

                    reply_embed = discord.Embed(
                        title="Replying To",
                        description=reply_message.content,
                        color=Color.random(),
                    )
                    reply_embed.set_author(
                        name=reply_message.author.name,
                        icon_url=reply_message.author.display_avatar.url,
                    )
                    reply_embed.timestamp = reply_message.created_at

                    embed_list.insert(0, reply_embed)
                except discord.errors.NotFound:
                    pass

            # Send message
            board_channel = await self.bot.fetch_channel(channel_id)
            board_message = await board_channel.send(
                content=f"**{react_count} {emoji}** | {message.author.mention} | <#{payload.channel_id}>",
                embeds=embed_list,
                view=view,
                files=[
                    await attachment.to_file() for attachment in message.attachments
                ],
            )

            async with self.fireboard_pool.acquire() as sql:
                # Insert message to DB
                await sql.execute(
                    "INSERT INTO fireMessages (serverID, msgID, boardMsgID, reactionAmount) VALUES (?, ?, ?, ?)",
                    (
                        payload.guild_id,
                        payload.message_id,
                        board_message.id,
                        react_count,
                    ),
                )
                await sql.commit()

            await self.refresh_fire_lists()
        except Exception as e:
            raise e
        finally:
            self.locked_messages.remove(payload.message_id)

    # Listen for reaction removal
    @commands.Cog.listener()
    async def on_raw_reaction_remove(self, payload: discord.RawReactionActionEvent):
        self.bot: discord.ext.commands.Bot

        queued = False

        # Stop if this is a DM
        if payload.guild_id is None:
            return

        # Lock system
        if payload.message_id in self.locked_messages:
            queued = True

            while payload.message_id in self.locked_messages:
                await asyncio.sleep(0.5)

        self.locked_messages.append(payload.message_id)

        try:
            fetched = False

            # Find server config
            for server in self.fire_settings:
                if server[0] == payload.guild_id:
                    react_minimum = server[1]
                    emoji = server[2]
                    channel_id = server[3]
                    ignore_bots = True if int(server[4]) == 1 else False

                    fetched = True

            # Stop if server has no config (fireboard isn't enabled)
            if not fetched:
                return

            # Stop if message is by Titanium
            if payload.message_author_id == self.bot.user.id:
                return

            # Stop if emoji doesn't match
            if str(payload.emoji) != emoji:
                return

            # --- Edit board message if it already exists ---
            if payload.message_id in [message[1] for message in self.fire_messages]:
                prev_react_count = [
                    message
                    for message in self.fire_messages
                    if message[1] == payload.message_id
                ][0][3]

                # Only fetch updated reaction count if I have queued
                if queued or prev_react_count is None:
                    # Fetch message and channel
                    try:
                        msg_channel = await self.bot.fetch_channel(payload.channel_id)
                        message = await msg_channel.fetch_message(payload.message_id)
                    except discord.errors.NotFound:
                        return

                    # Stop if not enough reactions
                    for reaction in message.reactions:
                        if str(reaction.emoji) == emoji:
                            react_count = reaction.count
                            break

                    if react_count < react_minimum:
                        return
                else:
                    react_count = None

                async with self.fireboard_pool.acquire() as sql:
                    # Set updated react count
                    if react_count is not None:
                        await sql.execute(
                            "UPDATE fireMessages SET reactionAmount = ? WHERE msgID = ?",
                            (
                                react_count,
                                payload.message_id,
                            ),
                        )
                        await self.refresh_fire_lists()
                    else:
                        await sql.execute(
                            "UPDATE fireMessages SET reactionAmount = reactionAmount - 1 WHERE msgID = ?",
                            (payload.message_id,),
                        )
                        await self.refresh_fire_lists()

                # Get message from message list
                message = [
                    message
                    for message in self.fire_messages
                    if message[1] == payload.message_id
                ][0]

                # Get board message
                board_channel = await self.bot.fetch_channel(channel_id)
                board_message = await board_channel.fetch_message(message[2])

                # Remove message if not enough reactions
                if message[3] < react_minimum:
                    await board_message.delete()

                    async with self.fireboard_pool.acquire() as sql:
                        await sql.execute(
                            "DELETE FROM fireMessages WHERE msgID = ?",
                            (payload.message_id,),
                        )
                        await sql.commit()

                    await self.refresh_fire_lists()

                    return

                # Workaround for lack of message author ID
                content = board_message.content
                content = content.replace(
                    f"{prev_react_count} {emoji}", f"{message[3]} {emoji}"
                )

                await board_message.edit(content=content)

                return

            # Stop if message is in a blacklisted channel
            if payload.channel_id in [
                channel[1] for channel in self.fire_channel_blacklist
            ]:
                return

            # Stop if message is by a blacklisted role
            guild = await self.bot.fetch_guild(payload.guild_id)
            member = await guild.fetch_member(payload.user_id)

            if any(
                role[1] in [role.id for role in member.roles]
                for role in self.fire_role_blacklist
            ):
                return

            # Fetch message and channel
            try:
                msg_channel = await self.bot.fetch_channel(payload.channel_id)
                message = await msg_channel.fetch_message(payload.message_id)
            except discord.errors.NotFound:
                return

            # Stop if message is by a bot
            if ignore_bots and message.author.bot:
                return

            # Check if this is a thread
            if isinstance(msg_channel, discord.Thread):
                # Check if parent channel is NSFW
                if msg_channel.parent.nsfw:
                    return
            else:
                # Stop if message is in an NSFW channel
                if message.channel.nsfw:
                    return

            # Get reaction count
            react_count = 0

            for reaction in message.reactions:
                if str(reaction.emoji) == emoji:
                    react_count = reaction.count
                    break

            # Stop if not enough reactions
            if react_count < react_minimum:
                return

            # --- Send message to fireboard ---

            # Create embed
            embed = discord.Embed(description=message.content, color=Color.random())
            embed.set_author(
                name=message.author.name, icon_url=message.author.display_avatar.url
            )
            embed.timestamp = message.created_at

            # Jump to message button
            view = View()
            view.add_item(
                discord.ui.Button(
                    label="Jump to Message",
                    url=message.jump_url,
                    style=discord.ButtonStyle.url,
                )
            )

            embed_list = [embed]

            # Add reply embed
            if message.reference:
                try:
                    reply_message = await msg_channel.fetch_message(
                        message.reference.message_id
                    )

                    reply_embed = discord.Embed(
                        title="Replying To",
                        description=reply_message.content,
                        color=Color.random(),
                    )
                    reply_embed.set_author(
                        name=reply_message.author.name,
                        icon_url=reply_message.author.display_avatar.url,
                    )
                    reply_embed.timestamp = reply_message.created_at

                    embed_list.insert(0, reply_embed)
                except discord.errors.NotFound:
                    pass

            # Send message
            board_channel = await self.bot.fetch_channel(channel_id)
            board_message = await board_channel.send(
                content=f"**{react_count} {emoji}** | {message.author.mention} | <#{payload.channel_id}>",
                embeds=embed_list,
                view=view,
                files=[
                    await attachment.to_file() for attachment in message.attachments
                ],
            )

            async with self.fireboard_pool.acquire() as sql:
                # Insert message to DB
                await sql.execute(
                    "INSERT INTO fireMessages (serverID, msgID, boardMsgID, reactionAmount) VALUES (?, ?, ?, ?)",
                    (
                        payload.guild_id,
                        payload.message_id,
                        board_message.id,
                        react_count,
                    ),
                )
                await sql.commit()

            await self.refresh_fire_lists()
        except Exception as e:
            raise e
        finally:
            self.locked_messages.remove(payload.message_id)

    # Listen for message reaction clear
    @commands.Cog.listener()
    async def on_raw_reaction_clear(self, payload: discord.RawReactionClearEvent):
        self.bot: discord.ext.commands.Bot

        # Stop if this is a DM
        if payload.guild_id is None:
            return

        # Lock system
        if payload.message_id in self.locked_messages:
            while payload.message_id in self.locked_messages:
                await asyncio.sleep(0.5)

        self.locked_messages.append(payload.message_id)

        try:
            # Only trigger if message is already in the fireboard DB
            if payload.message_id in [message[1] for message in self.fire_messages]:
                # Find server config
                for server in self.fire_settings:
                    if server[0] == payload.guild_id:
                        channel_id = server[3]

                # Get guild
                try:
                    guild: discord.Guild = await self.bot.fetch_guild(payload.guild_id)
                except discord.errors.NotFound:
                    return

                # Get message channel
                channel: discord.abc.GuildChannel = await guild.fetch_channel(
                    payload.channel_id
                )

                # Get our message
                message: discord.Message = await channel.fetch_message(
                    payload.message_id
                )

                # See if board message is already present
                for fire_message in self.fire_messages:
                    if fire_message[1] == message.id:
                        async with self.fireboard_pool.acquire() as sql:
                            try:
                                # Delete message
                                try:
                                    channel: discord.TextChannel = (
                                        await guild.fetch_channel(channel_id)
                                    )
                                except discord.errors.NotFound:
                                    await sql.execute(
                                        "DELETE FROM fireSettings WHERE serverID = ?",
                                        (payload.guild_id,),
                                    )
                                    await sql.commit()
                                    self.locked_messages.remove(payload.message_id)

                                    return

                                board_message = await channel.fetch_message(
                                    fire_message[2]
                                )
                                await board_message.delete()

                                # Delete message from DB
                                await sql.execute(
                                    "DELETE FROM fireMessages WHERE msgID = ?",
                                    (message.id,),
                                )
                                await sql.commit()

                                await self.refresh_fire_lists()

                                return
                            except discord.errors.NotFound:
                                # Delete message from DB
                                await sql.execute(
                                    "DELETE FROM fireMessages WHERE msgID = ?",
                                    (message.id,),
                                )
                                await sql.commit()

                                await self.refresh_fire_lists()

                                return
            else:
                return
        except Exception as e:
            raise e
        finally:
            self.locked_messages.remove(payload.message_id)

    # Listen for specific emoji being cleared
    @commands.Cog.listener()
    async def on_raw_reaction_clear_emoji(
        self, payload: discord.RawReactionClearEmojiEvent
    ):
        self.bot: discord.ext.commands.Bot

        # Stop if this is a DM
        if payload.guild_id is None:
            return

        # Lock system
        if payload.message_id in self.locked_messages:
            while payload.message_id in self.locked_messages:
                await asyncio.sleep(0.5)

        self.locked_messages.append(payload.message_id)

        try:
            # Only trigger if message is already in the fireboard DB
            if payload.message_id in [message[1] for message in self.fire_messages]:
                for server in self.fire_settings:
                    if server[0] == payload.guild_id:
                        emoji = server[2]
                        channel_id = server[3]

                # Only trigger if cleared emoji is our emoji
                if str(payload.emoji) == emoji:
                    # Fetch server
                    try:
                        guild: discord.Guild = await self.bot.fetch_guild(
                            payload.guild_id
                        )
                    except discord.errors.NotFound:
                        return

                    # Get message channel
                    channel: discord.abc.GuildChannel = await guild.fetch_channel(
                        payload.channel_id
                    )

                    # See if board message is already present
                    for fire_message in self.fire_messages:
                        if fire_message[1] == payload.message_id:
                            async with self.fireboard_pool.acquire() as sql:
                                try:
                                    # Fetch fireboard channel
                                    try:
                                        channel: discord.TextChannel = (
                                            await guild.fetch_channel(channel_id)
                                        )
                                    except discord.errors.NotFound:
                                        await sql.execute(
                                            "DELETE FROM fireSettings WHERE serverID = ?",
                                            (payload.guild_id,),
                                        )
                                        await sql.commit()

                                        return

                                    # Delete message
                                    board_message = await channel.fetch_message(
                                        fire_message[2]
                                    )
                                    await board_message.delete()

                                    # Delete message from DB
                                    await sql.execute(
                                        "DELETE FROM fireMessages WHERE msgID = ?",
                                        (payload.message_id,),
                                    )
                                    await sql.commit()

                                    await self.refresh_fire_lists()

                                    return
                                except discord.errors.NotFound:
                                    # Delete message from DB
                                    await sql.execute(
                                        "DELETE FROM fireMessages WHERE msgID = ?",
                                        (payload.message_id,),
                                    )
                                    await sql.commit()

                                    await self.refresh_fire_lists()

                                    return
            else:
                return
        except Exception as e:
            raise e
        finally:
            self.locked_messages.remove(payload.message_id)

    # Listen for message being deleted
    @commands.Cog.listener()
    async def on_raw_message_delete(self, payload: discord.RawMessageDeleteEvent):
        self.bot: discord.ext.commands.Bot

        # Stop if this is a DM
        if payload.guild_id is None:
            return

        # Lock system
        if payload.message_id in self.locked_messages:
            while payload.message_id in self.locked_messages:
                await asyncio.sleep(0.5)

        self.locked_messages.append(payload.message_id)

        try:
            # Only trigger if message is already in the fireboard DB
            if payload.message_id in [message[1] for message in self.fire_messages]:
                # Fetch server config
                for server in self.fire_settings:
                    if server[0] == payload.guild_id:
                        channel_id = server[3]

                # Fetch server
                try:
                    guild: discord.Guild = await self.bot.fetch_guild(payload.guild_id)
                except discord.errors.NotFound:
                    return

                # Get message channel
                channel: discord.abc.GuildChannel = await guild.fetch_channel(
                    payload.channel_id
                )

                # See if board message is already present
                for fire_message in self.fire_messages:
                    if fire_message[1] == payload.message_id:
                        async with self.fireboard_pool.acquire() as sql:
                            try:
                                # Fetch fireboard channel
                                try:
                                    channel: discord.TextChannel = (
                                        await guild.fetch_channel(channel_id)
                                    )
                                except discord.errors.NotFound:
                                    await sql.execute(
                                        "DELETE FROM fireSettings WHERE serverID = ?",
                                        (payload.guild_id,),
                                    )
                                    await sql.commit()

                                    return

                                # Delete message
                                board_message = await channel.fetch_message(
                                    fire_message[2]
                                )
                                await board_message.delete()

                                # Delete message from DB
                                await sql.execute(
                                    "DELETE FROM fireMessages WHERE msgID = ?",
                                    (payload.message_id,),
                                )
                                await sql.commit()

                                await self.refresh_fire_lists()

                                return
                            except discord.errors.NotFound:
                                # Delete message from DB
                                await sql.execute(
                                    "DELETE FROM fireMessages WHERE msgID = ?",
                                    (payload.message_id,),
                                )
                                await sql.commit()

                                await self.refresh_fire_lists()

                                return
            else:
                return
        except Exception as e:
            raise e
        finally:
            self.locked_messages.remove(payload.message_id)

    # Listen for message being edited
    @commands.Cog.listener()
    async def on_raw_message_edit(self, payload: discord.RawMessageUpdateEvent):
        self.bot: discord.ext.commands.Bot

        # Stop if this is a DM
        if payload.guild_id is None:
            return

        # Lock system
        if payload.message_id in self.locked_messages:
            while payload.message_id in self.locked_messages:
                await asyncio.sleep(0.5)

        self.locked_messages.append(payload.message_id)

        try:
            # Only trigger if message is already in the fireboard DB
            if payload.message_id in [message[1] for message in self.fire_messages]:
                # Fetch server config
                for server in self.fire_settings:
                    if server[0] == payload.guild_id:
                        channel_id = server[3]

                # Fetch server
                try:
                    guild: discord.Guild = await self.bot.fetch_guild(payload.guild_id)
                except discord.errors.NotFound:
                    return

                # Get message channel
                channel: discord.abc.GuildChannel = await guild.fetch_channel(
                    payload.channel_id
                )

                # Get our message
                message: discord.Message = await channel.fetch_message(
                    payload.message_id
                )

                embed = discord.Embed(description=message.content, color=Color.random())
                embed.set_author(
                    name=message.author.name, icon_url=message.author.display_avatar.url
                )
                embed.timestamp = message.created_at

                # Jump to message button
                view = View()
                view.add_item(
                    discord.ui.Button(
                        label="Jump to Message",
                        url=message.jump_url,
                        style=discord.ButtonStyle.url,
                    )
                )

                embed_list = [embed]

                # Add reply embed
                if message.reference:
                    try:
                        reply_message = await channel.fetch_message(
                            message.reference.message_id
                        )

                        reply_embed = discord.Embed(
                            title="Replying To",
                            description=reply_message.content,
                            color=Color.random(),
                        )
                        reply_embed.set_author(
                            name=reply_message.author.name,
                            icon_url=reply_message.author.display_avatar.url,
                        )
                        reply_embed.timestamp = reply_message.created_at

                        embed_list.insert(0, reply_embed)
                    except discord.errors.NotFound:
                        pass

                try:
                    channel: discord.TextChannel = await guild.fetch_channel(channel_id)
                except discord.errors.NotFound:
                    async with self.fireboard_pool.acquire() as sql:
                        await sql.execute(
                            "DELETE FROM fireSettings WHERE serverID = ?",
                            (payload.guild_id,),
                        )
                        await sql.commit()

                    return

                # Find previous fireboard message
                try:
                    for fire_message in self.fire_messages:
                        if (
                            fire_message[0] == payload.guild_id
                            and fire_message[1] == payload.message_id
                        ):
                            # Edit with updated embed - reaction amount stays the same
                            board_message = await channel.fetch_message(fire_message[2])

                            await board_message.edit(
                                embeds=embed_list, attachments=message.attachments
                            )
                except discord.errors.NotFound:  # Message not found
                    async with self.fireboard_pool.acquire() as sql:
                        # Delete message from DB
                        await sql.execute(
                            "DELETE FROM fireMessages WHERE msgID = ?",
                            (payload.message_id,),
                        )
                        await sql.commit()

                        await self.refresh_fire_lists()

                    return
            else:
                return
        except Exception as e:
            raise e
        finally:
            self.locked_messages.remove(payload.message_id)

    # Listen for fireboard channel delete
    @commands.Cog.listener()
    async def on_guild_channel_delete(self, channel: discord.abc.GuildChannel):
        # Only trigger if server has fireboard enabled
        if channel.guild.id in [guild[0] for guild in self.fire_settings]:
            for server in self.fire_settings:
                if server[0] == channel.guild.id:
                    if server[3] == channel.id:
                        async with self.fireboard_pool.acquire() as sql:
                            # Delete fireboard config
                            await sql.execute(
                                "DELETE FROM fireMessages WHERE serverID = ?",
                                (channel.guild.id,),
                            )
                            await sql.execute(
                                "DELETE FROM fireSettings WHERE serverID = ?",
                                (channel.guild.id,),
                            )
                            await sql.commit()

                        await self.refresh_fire_lists()

                        return
        else:
            return

    # Listen for server being left / deleted
    @commands.Cog.listener()
    async def on_guild_remove(self, guild: discord.Guild):
        # Only trigger if server has fireboard enabled
        if guild.id in [guild[0] for guild in self.fire_settings]:
            for server in self.fire_settings:
                if server[0] == guild.id:
                    async with self.fireboard_pool.acquire() as sql:
                        # Delete fireboard config
                        await sql.execute(
                            "DELETE FROM fireMessages WHERE serverID = ?", (guild.id,)
                        )
                        await sql.execute(
                            "DELETE FROM fireSettings WHERE serverID = ?", (guild.id,)
                        )
                        await sql.commit()

                    await self.refresh_fire_lists()

                    return
        else:
            return

    # Command group setup
    context = discord.app_commands.AppCommandContext(
        guild=True, dm_channel=False, private_channel=False
    )
    installs = discord.app_commands.AppInstallationType(guild=True, user=False)
    fireGroup = app_commands.Group(
        name="fireboard",
        description="Fireboard related commands.",
        allowed_contexts=context,
        allowed_installs=installs,
    )

    # Random fireboard message command
    @fireGroup.command(
        name="random", description="Get a random message from the fireboard."
    )
    @app_commands.describe(
        ephemeral="Optional: whether to send the command output as a dismissible message only visible to you. Defaults to false."
    )
    async def random_fireboard(
        self, interaction: discord.Interaction, ephemeral: bool = False
    ):
        await interaction.response.defer(ephemeral=ephemeral)

        channel_id = None

        # Find server config
        for server in self.fire_settings:
            if server[0] == interaction.guild_id:
                channel_id = server[3]

        if channel_id is None:
            embed = discord.Embed(
                title="Error",
                description="Fireboard is not enabled in this server.",
                color=Color.red(),
            )
            await interaction.followup.send(embed=embed, ephemeral=ephemeral)

            return

        # Fetch channel
        try:
            channel = await interaction.guild.fetch_channel(channel_id)
        except discord.errors.NotFound:
            embed = discord.Embed(
                title="Error",
                description="Can't find the fireboard channel. Please contact a server admin.",
                color=Color.red(),
            )
            await interaction.followup.send(embed=embed, ephemeral=ephemeral)

            return

        # Fetch messages
        async with self.fireboard_pool.acquire() as sql:
            messages = await sql.fetchall(
                "SELECT * FROM fireMessages WHERE serverID = ?", (interaction.guild_id,)
            )

            if not messages:
                embed = discord.Embed(
                    title="Error",
                    description="No messages found in the fireboard.",
                    color=Color.red(),
                )
                await interaction.followup.send(embed=embed, ephemeral=ephemeral)

                return
            else:
                while messages != []:
                    message = random.choice(messages)

                    try:
                        board_message = await channel.fetch_message(message[2])

                        view = View().from_message(board_message)
                        files = [
                            await attachment.to_file()
                            for attachment in board_message.attachments
                        ]

                        await interaction.followup.send(
                            content=board_message.content,
                            embeds=board_message.embeds,
                            view=view,
                            ephemeral=ephemeral,
                            files=files,
                            allowed_mentions=discord.AllowedMentions.none(),
                        )

                        return
                    except discord.errors.NotFound:
                        messages.remove(message)

                embed = discord.Embed(
                    title="Error",
                    description="No messages found in the fireboard.",
                    color=Color.red(),
                )
                await interaction.followup.send(embed=embed, ephemeral=ephemeral)

    # Command group setup
    context = discord.app_commands.AppCommandContext(
        guild=True, dm_channel=False, private_channel=False
    )
    installs = discord.app_commands.AppInstallationType(guild=True, user=False)
    perms = discord.Permissions(manage_guild=True)
    fireSetupGroup = app_commands.Group(
        name="fireboard-setup",
        description="Control the fireboard.",
        allowed_contexts=context,
        allowed_installs=installs,
        default_permissions=perms,
    )

    # Fireboard enable command
    @fireSetupGroup.command(
        name="enable", description="Enable the fireboard in the current channel."
    )
    async def enable_fireboard(self, interaction: discord.Interaction):
        await interaction.response.defer(ephemeral=True)

        # Check fireboard status
        if interaction.guild.id in [guild[0] for guild in self.fire_settings]:
            embed = discord.Embed(
                title="Fireboard is already enabled.", color=Color.green()
            )
            await interaction.followup.send(embed=embed, ephemeral=True)
        else:
            # Default settings
            react_minimum = 3
            emoji = "🔥"
            channel_id = interaction.channel_id
            ignore_bots = True

            embed = discord.Embed(
                title="Fireboard",
                description="This channel has been configured as the server fireboard.",
                color=Color.random(),
            )
            embed.set_footer(text="Feel free to delete this message!")

            try:
                channel = await interaction.guild.fetch_channel(channel_id)
                await channel.send(embed=embed)
            except discord.errors.Forbidden or discord.errors.NotFound:
                embed = discord.Embed(
                    title="Error",
                    description="Looks like I can't send messages in this channel. Check permissions and try again.",
                    color=Color.random(),
                )
                await interaction.followup.send(embed=embed, ephemeral=True)

                return

            async with self.fireboard_pool.acquire() as sql:
                # Insert to DB, refresh lists
                await sql.execute(
                    "INSERT INTO fireSettings (serverID, reactionAmount, emoji, channelID, ignoreBots) VALUES (?, ?, ?, ?, ?)",
                    (
                        interaction.guild_id,
                        react_minimum,
                        emoji,
                        channel_id,
                        ignore_bots,
                    ),
                )
                await sql.commit()

            await self.refresh_fire_lists()

            embed = discord.Embed(
                title="Enabled",
                description="Fireboard has been enabled in the current channel.",
                color=Color.green(),
            )
            embed.add_field(
                name="Info",
                value=f"**Reaction Requirement:** `{react_minimum} reactions`\n**Fireboard Channel:** <#{channel_id}>\n**Emoji:** {emoji}\n**Ignore Bots:** `{ignore_bots}`",
            )

            await interaction.followup.send(embed=embed, ephemeral=True)

    class ConfirmDisableView(View):
        def __init__(self):
            super().__init__(timeout=60)

        async def disable_fireboard(
            self, interaction: discord.Interaction, pool: asqlite.Pool
        ):
            async with pool.acquire() as sql:
                try:
                    await sql.execute(
                        "DELETE FROM fireMessages WHERE serverID = ?",
                        (interaction.guild_id,),
                    )
                    await sql.execute(
                        "DELETE FROM fireSettings WHERE serverID = ?",
                        (interaction.guild_id,),
                    )
                    await sql.execute(
                        "DELETE FROM fireChannelBlacklist WHERE serverID = ?",
                        (interaction.guild_id,),
                    )
                    await sql.execute(
                        "DELETE FROM fireRoleBlacklist WHERE serverID = ?",
                        (interaction.guild_id,),
                    )
                    await sql.commit()
                    return True
                except Exception:
                    return False

        @discord.ui.button(label="Disable", style=discord.ButtonStyle.red)
        async def confirm(
            self, interaction: discord.Interaction, button: discord.ui.Button
        ):
            await interaction.response.defer(ephemeral=True)

            success = await self.disable_fireboard(interaction, self.pool)

            if success:
                embed = discord.Embed(
                    title="Done!",
                    description="Fireboard was disabled.",
                    color=Color.green(),
                )
                await self.cog.refresh_fire_lists()  # pylint: disable=no-member
            else:
                embed = discord.Embed(
                    title="Error",
                    description="Failed to disable fireboard.",
                    color=Color.red(),
                )

            await interaction.edit_original_response(embed=embed, view=None)
            self.stop()

        async def on_timeout(self):
            for item in self.children:
                item.disabled = True

            embed = discord.Embed(
                title="Timeout",
                description="You didn't press the button in time.",
                color=Color.red(),
            )
            await self.message.edit(embed=embed, view=self)

    # Fireboard disable command
    @fireSetupGroup.command(name="disable", description="Disable the server fireboard.")
    async def disable_fireboard(self, interaction: discord.Interaction):
        await interaction.response.defer(ephemeral=True)

        if interaction.guild_id in [guild[0] for guild in self.fire_settings]:
            view = self.ConfirmDisableView()
            view.pool = self.fireboard_pool
            view.cog = self

            embed = discord.Embed(
                title="Are you sure?",
                description="All data about this server's fireboard will be deleted. This cannot be undone!",
                color=Color.orange(),
            )

            message = await interaction.followup.send(
                embed=embed, view=view, ephemeral=True, wait=True
            )
            view.message = message
        else:
            await interaction.followup.send(
                "Fireboard is not enabled in this server!", ephemeral=True
            )

    # Fireboard server info command
    @fireSetupGroup.command(
        name="info", description="View fireboard config for this server."
    )
    async def fireboard_info(self, interaction: discord.Interaction):
        await interaction.response.defer(ephemeral=True)

        # Check fireboard status
        if interaction.guild.id in [guild[0] for guild in self.fire_settings]:
            # Fetch server settings
            for server in self.fire_settings:
                if server[0] == interaction.guild_id:
                    react_minimum = server[1]
                    emoji = server[2]
                    channel_id = server[3]
                    ignore_bots = True if int(server[4]) == 1 else False

            embed = discord.Embed(
                title="Server Fireboard Settings",
                description=f"**Reaction Requirement:** `{react_minimum} reactions`\n**Fireboard Channel:** <#{channel_id}>\n**Emoji:** {emoji}\n**Ignore Bots:** `{ignore_bots}`",
                color=Color.random(),
            )

            await interaction.followup.send(embed=embed, ephemeral=True)
        else:
            embed = discord.Embed(title="Fireboard is not enabled.", color=Color.red())

            await interaction.followup.send(embed=embed, ephemeral=True)

    # Fireboard set emoji command
    @fireSetupGroup.command(name="emoji", description="Set a custom fireboard emoji.")
    async def fireboard_emoji(self, interaction: discord.Interaction):
        await interaction.response.defer(ephemeral=False)

        # Check fireboard status
        if interaction.guild.id in [guild[0] for guild in self.fire_settings]:
            embed = discord.Embed(
                title="Waiting for Reaction",
                description="🔄 React with this message with your target emoji to set the fireboard emoji.",
                color=Color.orange(),
            )

            msg = await interaction.followup.send(embed=embed, ephemeral=False)

            def check(reaction, user):
                return user == interaction.user and reaction.message.id == msg.id

            # Wait for a reaction
            try:
                reaction, user = await self.bot.wait_for(
                    "reaction_add", timeout=60.0, check=check
                )

                reaction: discord.Reaction = reaction

                async with self.fireboard_pool.acquire() as sql:
                    # Change emoji in DB, refresh lists
                    await sql.execute(
                        "UPDATE fireSettings SET emoji = ? WHERE serverID = ?",
                        (
                            str(reaction.emoji),
                            interaction.guild_id,
                        ),
                    )
                    await sql.commit()

                embed = discord.Embed(
                    title="Emoji Set",
                    description=f"Set emoji to **{str(reaction.emoji)}.**",
                    color=Color.green(),
                )

                await self.refresh_fire_lists()
                await interaction.edit_original_response(embed=embed)
            except asyncio.TimeoutError:  # Timed out
                embed = discord.Embed(
                    title="Timed Out",
                    description="You didn't react in time.",
                    color=Color.red(),
                )

                await interaction.edit_original_response(embed=embed)
        else:
            embed = discord.Embed(title="Fireboard is not enabled.", color=Color.red())

            await interaction.followup.send(embed=embed, ephemeral=False)

    # Fireboard set channel command
    @fireSetupGroup.command(
        name="channel",
        description="Set the channel for fireboard messages to be sent in.",
    )
    async def fireboard_channel(
        self, interaction: discord.Interaction, channel: discord.TextChannel
    ):
        await interaction.response.defer(ephemeral=True)

        # Check fireboard status
        if interaction.guild.id in [guild[0] for guild in self.fire_settings]:
            embed = discord.Embed(
                title="Fireboard",
                description="This channel has been configured as the server fireboard.",
                color=Color.random(),
            )
            embed.set_footer(text="Feel free to delete this message!")

            try:
                await channel.send(embed=embed)
            except discord.errors.NotFound:
                embed = discord.Embed(
                    title="Error",
                    description="Looks like I can't find that channel. Check permissions and try again.",
                    color=Color.random(),
                )
                await interaction.followup.send(embed=embed, ephemeral=True)

                return
            except discord.errors.Forbidden as e:
                embed = discord.Embed(
                    title="Error",
                    description="Looks like I can't send messages in that channel. Check permissions and try again.",
                    color=Color.red(),
                )
                await interaction.followup.send(embed=embed, ephemeral=True)

                return

            async with self.fireboard_pool.acquire() as sql:
                # Update channel in DB, refresh lists
                await sql.execute(
                    "UPDATE fireSettings SET channelID = ? WHERE serverID = ?",
                    (
                        channel.id,
                        interaction.guild_id,
                    ),
                )
                await sql.commit()

            await self.refresh_fire_lists()

            embed = discord.Embed(
                title="Channel Set",
                description=f"Fireboard channel has been set to **{channel.mention}.**",
                color=Color.green(),
            )
            await interaction.followup.send(embed=embed, ephemeral=True)
        else:
            embed = discord.Embed(title="Fireboard is not enabled.", color=Color.red())

            await interaction.followup.send(embed=embed, ephemeral=True)

    # Fireboard set requirement command
    @fireSetupGroup.command(
        name="requirement",
        description="Set required reaction amount for message to be posted on the fireboard.",
    )
    async def fireboard_requirement(
        self, interaction: discord.Interaction, amount: int
    ):
        await interaction.response.defer(ephemeral=True)

        # Check fireboard status
        if interaction.guild.id in [guild[0] for guild in self.fire_settings]:
            embed = discord.Embed(
                title="Set",
                description=f"Reaction requirement has been set to **{amount} reactions.**",
                color=Color.green(),
            )

            async with self.fireboard_pool.acquire() as sql:
                # Update reaction requirement in DB, refresh lists
                await sql.execute(
                    "UPDATE fireSettings SET reactionAmount = ? WHERE serverID = ?",
                    (
                        amount,
                        interaction.guild_id,
                    ),
                )
                await sql.commit()

            await self.refresh_fire_lists()
            await interaction.followup.send(embed=embed, ephemeral=True)
        else:
            embed = discord.Embed(title="Fireboard is not enabled.", color=Color.red())

            await interaction.followup.send(embed=embed, ephemeral=True)

    # Fireboard ignore bots command
    @fireSetupGroup.command(
        name="ignore-bots",
        description="Whether bot messages are ignored in the fireboard. Defaults to true.",
    )
    async def fireboard_ignore_bots(
        self, interaction: discord.Interaction, value: bool
    ):
        await interaction.response.defer(ephemeral=True)

        # Check fireboard status
        if interaction.guild.id in [guild[0] for guild in self.fire_settings]:
            embed = discord.Embed(
                title="Set",
                description=f"Bot messages will **{'be ignored.' if value else 'not be ignored.'}**",
                color=Color.green(),
            )

            async with self.fireboard_pool.acquire() as sql:
                # Update setting in DB, refresh lists
                await sql.execute(
                    "UPDATE fireSettings SET ignoreBots = ? WHERE serverID = ?",
                    (
                        value,
                        interaction.guild_id,
                    ),
                )
                await sql.commit()

            await self.refresh_fire_lists()
            await interaction.followup.send(embed=embed, ephemeral=True)
        else:
            embed = discord.Embed(title="Fireboard is not enabled.", color=Color.red())

            await interaction.followup.send(embed=embed, ephemeral=True)

    # Fireboard role blacklist
    @fireSetupGroup.command(
        name="channel-blacklist",
        description="Toggle the blacklist for a channel. NSFW channels are always blacklisted.",
    )
    async def fireboard_channel_blacklist(
        self, interaction: discord.Interaction, channel: discord.abc.GuildChannel
    ):
        await interaction.response.defer(ephemeral=True)

        # Check fireboard status
        if interaction.guild_id in [guild[0] for guild in self.fire_settings]:
            async with self.fireboard_pool.acquire() as sql:
                if channel.id in [
                    channelEntry[1] for channelEntry in self.fire_channel_blacklist
                ]:
                    await sql.execute(
                        "DELETE FROM fireChannelBlacklist WHERE serverID = ? AND channelID = ?",
                        (
                            interaction.guild_id,
                            channel.id,
                        ),
                    )
                    await sql.commit()

                    await self.refresh_fire_lists()

                    embed = discord.Embed(
                        title="Set",
                        description=f"Removed {channel.mention} from the channel blacklist.",
                    )
                    await interaction.followup.send(embed=embed, ephemeral=True)
                else:
                    await sql.execute(
                        "INSERT INTO fireChannelBlacklist (serverID, channelID) VALUES (?, ?)",
                        (
                            interaction.guild_id,
                            channel.id,
                        ),
                    )
                    await sql.commit()

                    await self.refresh_fire_lists()

                    embed = discord.Embed(
                        title="Set",
                        description=f"Added {channel.mention} to the channel blacklist.",
                    )
                    await interaction.followup.send(embed=embed, ephemeral=True)
        else:
            embed = discord.Embed(title="Fireboard is not enabled.", color=Color.red())

            await interaction.followup.send(embed=embed, ephemeral=True)

    # Fireboard role blacklist
    @fireSetupGroup.command(
        name="role-blacklist", description="Toggle the blacklist for a role."
    )
    async def fireboard_role_blacklist(
        self, interaction: discord.Interaction, role: discord.Role
    ):
        await interaction.response.defer(ephemeral=True)

        # Check fireboard status
        if interaction.guild_id in [guild[0] for guild in self.fire_settings]:
            async with self.fireboard_pool.acquire() as sql:
                if role.id in [roleEntry[1] for roleEntry in self.fire_role_blacklist]:
                    await sql.execute(
                        "DELETE FROM fireRoleBlacklist WHERE serverID = ? AND roleID = ?",
                        (
                            interaction.guild_id,
                            role.id,
                        ),
                    )
                    await sql.commit()

                    await self.refresh_fire_lists()

                    embed = discord.Embed(
                        title="Set",
                        description=f"Removed {role.mention} from the role blacklist.",
                    )
                    await interaction.followup.send(embed=embed, ephemeral=True)
                else:
                    await sql.execute(
                        "INSERT INTO fireRoleBlacklist (serverID, roleID) VALUES (?, ?)",
                        (
                            interaction.guild_id,
                            role.id,
                        ),
                    )
                    await sql.commit()

                    await self.refresh_fire_lists()

                    embed = discord.Embed(
                        title="Set",
                        description=f"Added {role.mention} to the role blacklist.",
                    )
                    await interaction.followup.send(embed=embed, ephemeral=True)
        else:
            embed = discord.Embed(title="Fireboard is not enabled.", color=Color.red())

            await interaction.followup.send(embed=embed, ephemeral=True)

    # Fireboard role blacklist
    @fireSetupGroup.command(
        name="blacklists", description="View this server's role and channel blacklists."
    )
    async def fireboard_blacklists(self, interaction: discord.Interaction):
        await interaction.response.defer(ephemeral=True)

        # Check fireboard status
        if interaction.guild_id in [guild[0] for guild in self.fire_settings]:

            class BlacklistViewer(View):
                def __init__(self):
                    super().__init__(timeout=240)

                    self.fire_channel_blacklist: list
                    self.fire_role_blacklist: list
                    self.interaction: discord.Interaction

                async def on_timeout(self) -> None:
                    for item in self.children:
                        item.disabled = True

                    await self.interaction.edit_original_response(view=self)

                @discord.ui.button(
                    label="Role Blacklist",
                    style=discord.ButtonStyle.gray,
                    row=0,
                    custom_id="role",
                    disabled=True,
                )
                async def role(
                    self, interaction: discord.Interaction, button: discord.ui.Button
                ):
                    await interaction.response.defer(ephemeral=True)

                    for item in self.children:
                        if item.custom_id == "channel":
                            item.disabled = False
                        else:
                            item.disabled = True

                    my_roles = []

                    for role in self.fire_role_blacklist:
                        if role[0] == interaction.guild_id:
                            my_roles.append(f"<@&{role[1]}>")

                    if my_roles != []:
                        embed = discord.Embed(
                            title="Role Blacklist",
                            description="\n".join(my_roles),
                            color=Color.random(),
                        )
                        await interaction.edit_original_response(embed=embed, view=self)
                    else:
                        embed = discord.Embed(
                            title="Role Blacklist",
                            description="No roles have been blacklisted.",
                            color=Color.random(),
                        )
                        await interaction.edit_original_response(embed=embed, view=self)

                @discord.ui.button(
                    label="Channel Blacklist",
                    style=discord.ButtonStyle.gray,
                    row=0,
                    custom_id="channel",
                )
                async def channel(
                    self, interaction: discord.Interaction, button: discord.ui.Button
                ):
                    await interaction.response.defer(ephemeral=True)

                    for item in self.children:
                        if item.custom_id == "role":
                            item.disabled = False
                        else:
                            item.disabled = True

                    my_channels = []

                    for channel in self.fire_channel_blacklist:
                        if channel[0] == interaction.guild_id:
                            my_channels.append(f"<#{channel[1]}>")

                    if my_channels != []:
                        embed = discord.Embed(
                            title="Channel Blacklist",
                            description="\n".join(my_channels),
                            color=Color.random(),
                        )
                        await interaction.edit_original_response(embed=embed, view=self)
                    else:
                        embed = discord.Embed(
                            title="Channel Blacklist",
                            description="No channels have been blacklisted.",
                            color=Color.random(),
                        )
                        await interaction.edit_original_response(embed=embed, view=self)

            view_instance = BlacklistViewer()
            view_instance.fire_channel_blacklist = self.fire_channel_blacklist
            view_instance.fire_role_blacklist = self.fire_role_blacklist
            view_instance.interaction = interaction

            my_roles = []

            for role in self.fire_role_blacklist:
                if role[0] == interaction.guild_id:
                    my_roles.append(f"<@&{role[1]}>")

            if my_roles != []:
                embed = discord.Embed(
                    title="Role Blacklist",
                    description="\n".join(my_roles),
                    color=Color.random(),
                )
                await interaction.followup.send(
                    embed=embed, view=view_instance, ephemeral=True
                )
            else:
                embed = discord.Embed(
                    title="Role Blacklist",
                    description="No roles have been blacklisted.",
                    color=Color.random(),
                )
                await interaction.followup.send(
                    embed=embed, view=view_instance, ephemeral=True
                )
        else:
            embed = discord.Embed(title="Fireboard is not enabled.", color=Color.red())

            await interaction.followup.send(embed=embed, ephemeral=True)


async def setup(bot):import asyncio
import random
import json
import os

import discord
from discord import Color, app_commands
from discord.ext import commands
from discord.ui import View

FIREBOARD_PATH = "assets/cogs/files/fireboard.json"

def load_data():
    if not os.path.exists(FIREBOARD_PATH):
        return {}
    with open(FIREBOARD_PATH, "r") as f:
        return json.load(f)

def save_data(data):
    os.makedirs(os.path.dirname(FIREBOARD_PATH), exist_ok=True)
    with open(FIREBOARD_PATH, "w") as f:
        json.dump(data, f, indent=2)

class Fireboard(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.data = load_data()
        self.locked_messages = []

    def save(self):
        save_data(self.data)

    def get_guild(self, guild_id):
        return self.data.setdefault(str(guild_id), {
            "settings": None,
            "messages": [],
            "role_blacklist": [],
            "channel_blacklist": []
        })

    @commands.Cog.listener()
    async def on_raw_reaction_add(self, payload: discord.RawReactionActionEvent):
        if payload.guild_id is None:
            return
        guild_data = self.get_guild(payload.guild_id)
        settings = guild_data["settings"]
        if not settings:
            return
        react_minimum = settings["reactionAmount"]
        emoji = settings["emoji"]
        channel_id = settings["channelID"]
        ignore_bots = settings["ignoreBots"]

        if str(payload.emoji) != emoji:
            return
        if payload.channel_id in guild_data["channel_blacklist"]:
            return
        if payload.message_id in self.locked_messages:
            return
        self.locked_messages.append(payload.message_id)
        try:
            channel = await self.bot.fetch_channel(payload.channel_id)
            message = await channel.fetch_message(payload.message_id)
            if ignore_bots and message.author.bot:
                return
            if hasattr(message.channel, "nsfw") and message.channel.nsfw:
                return
            react_count = 0
            for reaction in message.reactions:
                if str(reaction.emoji) == emoji:
                    react_count = reaction.count
                    break
            if react_count < react_minimum:
                return
            # Already on fireboard?
            for m in guild_data["messages"]:
                if m["msgID"] == payload.message_id:
                    return
            # Send to fireboard
            board_channel = await self.bot.fetch_channel(channel_id)
            embed = discord.Embed(description=message.content, color=Color.random())
            embed.set_author(name=message.author.name, icon_url=message.author.display_avatar.url)
            embed.timestamp = message.created_at
            view = View()
            view.add_item(discord.ui.Button(label="Jump to Message", url=message.jump_url, style=discord.ButtonStyle.url))
            files = [await a.to_file() for a in message.attachments]
            board_message = await board_channel.send(
                content=f"**{react_count} {emoji}** | {message.author.mention} | <#{payload.channel_id}>",
                embed=embed, view=view, files=files
            )
            guild_data["messages"].append({
                "msgID": payload.message_id,
                "boardMsgID": board_message.id,
                "reactionAmount": react_count
            })
            self.save()
        finally:
            if payload.message_id in self.locked_messages:
                self.locked_messages.remove(payload.message_id)

    @commands.Cog.listener()
    async def on_raw_reaction_remove(self, payload: discord.RawReactionActionEvent):
        if payload.guild_id is None:
            return
        guild_data = self.get_guild(payload.guild_id)
        settings = guild_data["settings"]
        if not settings:
            return
        emoji = settings["emoji"]
        channel_id = settings["channelID"]
        if str(payload.emoji) != emoji:
            return
        for m in guild_data["messages"]:
            if m["msgID"] == payload.message_id:
                channel = await self.bot.fetch_channel(channel_id)
                try:
                    board_message = await channel.fetch_message(m["boardMsgID"])
                    await board_message.delete()
                except Exception:
                    pass
                guild_data["messages"].remove(m)
                self.save()
                break

    @app_commands.command(name="fireboard_enable", description="Enable the fireboard in this channel.")
    async def fireboard_enable(self, interaction: discord.Interaction):
        await interaction.response.defer(ephemeral=True)
        guild_data = self.get_guild(interaction.guild_id)
        if guild_data["settings"]:
            await interaction.followup.send("Fireboard is already enabled.", ephemeral=True)
            return
        guild_data["settings"] = {
            "reactionAmount": 3,
            "emoji": "🔥",
            "channelID": interaction.channel_id,
            "ignoreBots": True
        }
        self.save()
        await interaction.followup.send("Fireboard enabled in this channel.", ephemeral=True)

    @app_commands.command(name="fireboard_disable", description="Disable the fireboard.")
    async def fireboard_disable(self, interaction: discord.Interaction):
        await interaction.response.defer(ephemeral=True)
        guild_data = self.get_guild(interaction.guild_id)
        guild_data["settings"] = None
        guild_data["messages"] = []
        self.save()
        await interaction.followup.send("Fireboard disabled.", ephemeral=True)

    @app_commands.command(name="fireboard_info", description="Show fireboard settings.")
    async def fireboard_info(self, interaction: discord.Interaction):
        await interaction.response.defer(ephemeral=True)
        guild_data = self.get_guild(interaction.guild_id)
        settings = guild_data["settings"]
        if not settings:
            await interaction.followup.send("Fireboard is not enabled.", ephemeral=True)
            return
        embed = discord.Embed(
            title="Fireboard Settings",
            description=f"**Reaction Requirement:** `{settings['reactionAmount']}`\n"
                        f"**Fireboard Channel:** <#{settings['channelID']}>\n"
                        f"**Emoji:** {settings['emoji']}\n"
                        f"**Ignore Bots:** `{settings['ignoreBots']}`",
            color=Color.random()
        )
        await interaction.followup.send(embed=embed, ephemeral=True)

async def setup(bot):
    await bot.add_cog(Fireboard(bot))