src/commands/settings/welcome.ts

import { LoadingEmbed } from "../../utils/defaults.js";
import Discord, {
    CommandInteraction,
    AutocompleteInteraction,
    ActionRowBuilder,
    ButtonBuilder,
    ButtonStyle,
    APIMessageComponentEmoji,
    ChannelSelectMenuBuilder,
    RoleSelectMenuBuilder,
    RoleSelectMenuInteraction,
    ChannelSelectMenuInteraction,
    ButtonInteraction,
    ModalBuilder,
    TextInputBuilder,
    TextInputStyle,
    ModalSubmitInteraction
} from "discord.js";
import type { SlashCommandSubcommandBuilder } from "discord.js";
import EmojiEmbed from "../../utils/generateEmojiEmbed.js";
import client from "../../utils/client.js";
import getEmojiByName from "../../utils/getEmojiByName.js";
import convertCurlyBracketString from "../../utils/convertCurlyBracketString.js";
import { modalInteractionCollector } from "../../utils/dualCollector.js";

const command = (builder: SlashCommandSubcommandBuilder) =>
    builder.setName("welcome").setDescription("Messages and roles sent or given when someone joins the server");

const callback = async (interaction: CommandInteraction): Promise<void> => {
    const { renderChannel } = client.logger;
    const m = await interaction.reply({
        embeds: LoadingEmbed,
        fetchReply: true,
        ephemeral: true
    });
    let closed = false;
    let config = await client.database.guilds.read(interaction.guild!.id);
    let data = Object.assign({}, config.welcome);
    do {
        const buttons = new ActionRowBuilder<ButtonBuilder>().addComponents(
            new ButtonBuilder()
                .setCustomId("switch")
                .setLabel(data.enabled ? "Enabled" : "Disabled")
                .setStyle(data.enabled ? ButtonStyle.Success : ButtonStyle.Danger)
                .setEmoji(
                    getEmojiByName(data.enabled ? "CONTROL.TICK" : "CONTROL.CROSS", "id") as APIMessageComponentEmoji
                ),
            new ButtonBuilder()
                .setCustomId("message")
                .setLabel((data.message ? "Change" : "Set") + "Message")
                .setStyle(ButtonStyle.Primary)
                .setEmoji(getEmojiByName("ICONS.EDIT", "id") as APIMessageComponentEmoji),
            new ButtonBuilder()
                .setCustomId("channelDM")
                .setLabel("Send in DMs")
                .setStyle(ButtonStyle.Primary)
                .setDisabled(data.channel === "dm"),
            new ButtonBuilder()
                .setCustomId("role")
                .setLabel("Clear Role")
                .setStyle(ButtonStyle.Danger)
                .setEmoji(getEmojiByName("CONTROL.CROSS", "id") as APIMessageComponentEmoji),
            new ButtonBuilder()
                .setCustomId("save")
                .setLabel("Save")
                .setStyle(ButtonStyle.Success)
                .setEmoji(getEmojiByName("ICONS.SAVE", "id") as APIMessageComponentEmoji)
                .setDisabled(
                    data.enabled === config.welcome.enabled &&
                        data.message === config.welcome.message &&
                        data.role === config.welcome.role &&
                        data.ping === config.welcome.ping &&
                        data.channel === config.welcome.channel
                )
        );

        const channelMenu = new ActionRowBuilder<ChannelSelectMenuBuilder>().addComponents(
            new ChannelSelectMenuBuilder()
                .setCustomId("channel")
                .setPlaceholder("Select a channel to send welcome messages to")
        );
        const roleMenu = new ActionRowBuilder<RoleSelectMenuBuilder>().addComponents(
            new RoleSelectMenuBuilder()
                .setCustomId("roleToGive")
                .setPlaceholder("Select a role to give to the member when they join the server")
        );
        const pingMenu = new ActionRowBuilder<RoleSelectMenuBuilder>().addComponents(
            new RoleSelectMenuBuilder()
                .setCustomId("roleToPing")
                .setPlaceholder("Select a role to ping when a member joins the server")
        );

        const embed = new EmojiEmbed()
            .setTitle("Welcome Settings")
            .setStatus("Success")
            .setDescription(
                `${getEmojiByName(data.enabled ? "CONTROL.TICK" : "CONTROL.CROSS")} Welcome messages and roles are ${
                    data.enabled ? "enabled" : "disabled"
                }\n` +
                    `**Welcome message:** ${
                        data.message
                            ? `\n> ` +
                              (await convertCurlyBracketString(
                                  data.message,
                                  interaction.user.id,
                                  interaction.user.username,
                                  interaction.guild!.name,
                                  interaction.guild!.members
                              ))
                            : "*None*"
                    }\n` +
                    `**Send message in:** ` +
                    (data.channel ? (data.channel == "dm" ? "DMs" : renderChannel(data.channel)) : `*None set*`) +
                    `\n` +
                    `**Role to ping:** ` +
                    (data.ping ? `<@&${data.ping}>` : `*None set*`) +
                    `\n` +
                    `**Role given on join:** ` +
                    (data.role ? `<@&${data.role}>` : `*None set*`)
            );

        await interaction.editReply({
            embeds: [embed],
            components: [buttons, channelMenu, roleMenu, pingMenu]
        });

        let i: RoleSelectMenuInteraction | ChannelSelectMenuInteraction | ButtonInteraction;
        try {
            i = (await m.awaitMessageComponent({
                filter: (interaction) => interaction.user.id === interaction.user.id,
                time: 300000
            })) as RoleSelectMenuInteraction | ChannelSelectMenuInteraction | ButtonInteraction;
        } catch (e) {
            closed = true;
            continue;
        }

        if (i.isButton()) {
            switch (i.customId) {
                case "switch": {
                    await i.deferUpdate();
                    data.enabled = !data.enabled;
                    break;
                }
                case "message": {
                    const modal = new ModalBuilder()
                        .setCustomId("modal")
                        .setTitle("Welcome Message")
                        .addComponents(
                            new ActionRowBuilder<TextInputBuilder>().addComponents(
                                new TextInputBuilder()
                                    .setCustomId("ex1")
                                    .setLabel("Server Info (1/3)")
                                    .setPlaceholder(
                                        `{serverName} - This server's name\n\n` +
                                            `These placeholders will be replaced with the server's name, etc..`
                                    )
                                    .setMaxLength(1)
                                    .setRequired(false)
                                    .setStyle(TextInputStyle.Paragraph)
                            ),
                            new ActionRowBuilder<TextInputBuilder>().addComponents(
                                new TextInputBuilder()
                                    .setCustomId("ex2")
                                    .setLabel("Member Counts (2/3) - {MemberCount:...}")
                                    .setPlaceholder(
                                        `{:all} - Total member count\n` +
                                            `{:humans} - Total non-bot users\n` +
                                            `{:bots} - Number of bots\n`
                                    )
                                    .setMaxLength(1)
                                    .setRequired(false)
                                    .setStyle(TextInputStyle.Paragraph)
                            ),
                            new ActionRowBuilder<TextInputBuilder>().addComponents(
                                new TextInputBuilder()
                                    .setCustomId("ex3")
                                    .setLabel("Member who joined (3/3) - {member:...}")
                                    .setPlaceholder(`{:name} - The members name\n`)
                                    .setMaxLength(1)
                                    .setRequired(false)
                                    .setStyle(TextInputStyle.Paragraph)
                            ),
                            new ActionRowBuilder<TextInputBuilder>().addComponents(
                                new TextInputBuilder()
                                    .setCustomId("message")
                                    .setPlaceholder("Enter a message to send when someone joins the server")
                                    .setValue(data.message ?? "")
                                    .setLabel("Message")
                                    .setStyle(TextInputStyle.Paragraph)
                            )
                        );
                    const button = new ActionRowBuilder<ButtonBuilder>().addComponents(
                        new ButtonBuilder()
                            .setCustomId("back")
                            .setLabel("Back")
                            .setStyle(ButtonStyle.Secondary)
                            .setEmoji(getEmojiByName("CONTROL.LEFT", "id") as APIMessageComponentEmoji)
                    );
                    await i.showModal(modal);
                    await i.editReply({
                        embeds: [
                            new EmojiEmbed()
                                .setTitle("Welcome Settings")
                                .setDescription("Modal opened. If you can't see it, click back and try again.")
                                .setStatus("Success")
                        ],
                        components: [button]
                    });

                    let out: ModalSubmitInteraction | null;
                    try {
                        out = (await modalInteractionCollector(m, interaction.user)) as ModalSubmitInteraction | null;
                    } catch (e) {
                        console.error(e);
                        out = null;
                    }
                    if (!out) break;
                    data.message = out.fields.getTextInputValue("message");
                    break;
                }
                case "save": {
                    await i.deferUpdate();
                    await client.database.guilds.write(interaction.guild!.id, { welcome: data });
                    config = await client.database.guilds.read(interaction.guild!.id);
                    data = Object.assign({}, config.welcome);
                    await client.memory.forceUpdate(interaction.guild!.id);
                    break;
                }
                case "channelDM": {
                    await i.deferUpdate();
                    data.channel = "dm";
                    break;
                }
                case "role": {
                    await i.deferUpdate();
                    data.role = null;
                    break;
                }
            }
        } else if (i.isRoleSelectMenu()) {
            await i.deferUpdate();
            switch (i.customId) {
                case "roleToGive": {
                    data.role = i.values[0]!;
                    break;
                }
                case "roleToPing": {
                    data.ping = i.values[0]!;
                    break;
                }
            }
        } else {
            await i.deferUpdate();
            data.channel = i.values[0]!;
        }
    } while (!closed);
    await interaction.deleteReply();
};

const check = (interaction: CommandInteraction, _partial: boolean = false) => {
    const member = interaction.member as Discord.GuildMember;
    if (!member.permissions.has("ManageGuild"))
        return "You must have the *Manage Server* permission to use this command";
    return true;
};

const autocomplete = async (interaction: AutocompleteInteraction): Promise<string[]> => {
    const validReplacements = ["serverName", "memberCount:all", "memberCount:bots", "memberCount:humans"];
    if (!interaction.guild) return [];
    const prompt = interaction.options.getString("message");
    const autocompletions = [];
    if (prompt === null) {
        for (const replacement of validReplacements) {
            autocompletions.push(`{${replacement}}`);
        }
        return autocompletions;
    }
    const beforeLastOpenBracket = prompt.match(/(.*){[^{}]{0,15}$/);
    const afterLastOpenBracket = prompt.match(/{[^{}]{0,15}$/);
    if (beforeLastOpenBracket !== null) {
        if (afterLastOpenBracket !== null) {
            for (const replacement of validReplacements) {
                if (replacement.startsWith(afterLastOpenBracket[0]!.slice(1))) {
                    autocompletions.push(`${beforeLastOpenBracket[1]}{${replacement}}`);
                }
            }
        } else {
            for (const replacement of validReplacements) {
                autocompletions.push(`${beforeLastOpenBracket[1]}{${replacement}}`);
            }
        }
    } else {
        for (const replacement of validReplacements) {
            autocompletions.push(`${prompt} {${replacement}}`);
        }
    }
    return autocompletions;
};

export { command, callback, check, autocomplete };