roles.js

const RoleMenu = require('../models/RoleMenu');
const {MessageActionRow, MessageSelectMenu} = require("discord.js");

// slashcommand handler
async function addRoleMenu(interaction) {
    const channel = interaction.options.getChannel('channel');
    const messageContent = interaction.options.getString('message');
    const type = interaction.options.getString('type');
    const verification = interaction.options.getBoolean('verification');
    const row1 = new MessageActionRow()
        .addComponents(
            new MessageSelectMenu()
                .setCustomId('selectRole')
                .setPlaceholder("Select a role.")
                .addOptions([
                    {
                        label: 'Placeholder',
                        value: 'placeholder'
                    }
                ])
        );
    const msg = await channel.send({content: messageContent, components: [row1]});
    let menu = new RoleMenu();
    menu.guildID = channel.guild.id;
    menu.channelID = channel.id;
    menu.messageID = msg.id;
    menu.verification = verification;
    menu.type = type;
    menu.roles = [];
    await menu.save();
    await interaction.reply({content: 'Role Menu has been created.', ephemeral: true});
}

async function deleteRoleMenu(interaction) {
    const channel = interaction.options.getChannel('channel');
    const messageID = interaction.options.getString('message_id');
    let menu = await RoleMenu.findOne({guildID: channel.guild.id, channelID: channel.id, messageID});
    if (channel.isText()) {
        const message = await channel.messages.fetch(messageID);
        if (message != null) {
            if (menu != null) {
                try {
                    await RoleMenu.deleteOne({_id: menu._id});
                    await message.delete();
                    await interaction.reply({content: 'Menu has been deleted.', ephemeral: true});
                } catch (e) {
                    await interaction.reply({content: 'Deleting the Menu has failed.', ephemeral: true});
                }
            } else {
                await interaction.reply({content: 'Please select a menu message.', ephemeral: true});
            }
        } else {
            await interaction.reply({content: 'The message ID does not exist in this channel.', ephemeral: true});
        }
    } else {
        await interaction.reply({content: 'Please select a text channel.', ephemeral: true});
    }
}

async function addRoleToMenu(interaction) {
    const channel = interaction.options.getChannel('channel');
    const messageID = interaction.options.getString('message_id');
    const role = interaction.options.getRole('role')
    if (channel.isText()) {
        var message = null;
        var messageSuccess = true;
        try {
            message = await channel.messages.fetch(messageID);
        } catch (e) {
            messageSuccess = false;
        }
        if (messageSuccess) {
            if (message != null) {
                let menu = await RoleMenu.findOne({
                    guildID: channel.guild.id,
                    channelID: channel.id,
                    messageID
                });
                if (menu != null) {
                    let components = message.components;
                    if (components[0].components[0].options[0].value === 'placeholder') {
                        components[0].components[0].options = [];
                    }
                    if (!menu.roles.map((role) => role.roleID).includes(role.id.toString())) {
                        components[0].components[0].addOptions({
                            label: role.name,
                            value: role.name.toLowerCase().replace(" ", "_")
                        });
                        menu.roles.push({
                            text: role.name,
                            value: role.name.toLowerCase().replace(" ", "_"),
                            roleID: role.id
                        });
                        await menu.save();
                        await message.edit({content: message.content, components});
                        await interaction.reply({
                            content: `Role ${role.name} has been added to the message.`,
                            ephemeral: true
                        });
                    } else {
                        await interaction.reply({
                            content: `Role ${role.name} is already added to the message.`,
                            ephemeral: true
                        });
                    }
                } else {
                    await interaction.reply({content: 'Please select a menu message.', ephemeral: true});
                }
            } else {
                await interaction.reply({
                    content: 'The message ID does not exist in this channel.',
                    ephemeral: true
                });
            }
        } else {
            await interaction.reply({
                content: 'The message ID was invalid.', ephemeral: true
            })
        }
    } else {
        await interaction.reply({content: 'Please select a text channel.', ephemeral: true});
    }
}

async function deleteRoleFromMenu(interaction) {
    const channel = interaction.options.getChannel('channel');
    const messageID = interaction.options.getString('message_id');
    const role = interaction.options.getRole('role');
    if (channel.isText()) {
        var message = null;
        var messageSuccess = true;
        try {
            message = await channel.messages.fetch(messageID);
        } catch (e) {
            messageSuccess = false;
        }
        if (messageSuccess) {
            if (message != null) {
                let menu = await RoleMenu.findOne({
                    guildID: channel.guild.id,
                    channelID: channel.id,
                    messageID
                });
                if (menu != null) {
                    if (menu.roles.map((role) => role.roleID).includes(role.id.toString())) {
                        const value = menu.roles[menu.roles.map(role => role.roleID).indexOf(role.id.toString())].value;
                        const index1 = menu.roles.map(role => role.value).indexOf(value);
                        menu.roles.splice(index1, 1);
                        if (message.components[0].components[0].options.length === 1) {
                            message.components[0].components[0].addOptions({
                                label: "Placeholder",
                                value: "placeholder"
                            });
                        }
                        const index2 = message.components[0].components[0].options
                            .map(option => option.value).indexOf(value);
                        message.components[0].components[0].options
                            .splice(index2, 1);
                        await message.edit({content: message.content, components: message.components});
                        await menu.save();
                        await interaction.reply({content: 'Role has been removed from menu.', ephemeral: true});
                    } else {
                        await interaction.reply({
                            content: 'This role has not been added to the menu.',
                            ephemeral: true
                        });
                    }
                } else {
                    await interaction.reply({content: 'Please select a menu message.', ephemeral: true});
                }
            } else {
                await interaction.reply({
                    content: 'The message ID does not exist in this channel.',
                    ephemeral: true
                });
            }
        } else {
            await interaction.reply({
                content: 'The message ID was invalid.', ephemeral: true
            })
        }
    }
}

async function editRoleMenu(interaction) {
    const channel = interaction.options.getChannel('channel');
    const messageID = interaction.options.getString('message_id');
    const messageContent = interaction.options.getString('message');
    const type = interaction.options.getString('type');
    const verification = interaction.options.getBoolean('verification');
    if (channel.isText()) {
        var message = null;
        var messageSuccess = true;
        try {
            message = await channel.messages.fetch(messageID);
        } catch (e) {
            messageSuccess = false;
        }
        if (messageSuccess) {
            if (message != null) {
                let menu = await RoleMenu.findOne({
                    guildID: channel.guild.id,
                    channelID: channel.id,
                    messageID
                });
                if (menu != null) {
                    if (messageContent != null) {
                        await message.edit({content: messageContent, components: message.components});
                    }
                    if (type != null) {
                        menu.type = type;
                    }
                    if (verification != null) {
                        menu.verification = verification;
                    }
                    await menu.save();
                    await interaction.reply({content: 'Menu has been updated.', ephemeral: true});
                } else {
                    await interaction.reply({content: 'Please select a menu message.', ephemeral: true});
                }
            } else {
                await interaction.reply({
                    content: 'The message ID does not exist in this channel.',
                    ephemeral: true
                });
            }
        } else {
            await interaction.reply({
                content: 'The message ID was invalid.', ephemeral: true
            })
        }
    }
}

const slashCommandHandler = async (interaction) => {
    console.log('slashCommandHandler');
    if (interaction.commandName === 'add_role_menu') {
        await addRoleMenu(interaction);
    } else if (interaction.commandName === 'delete_role_menu') {
        await deleteRoleMenu(interaction);
    } else if (interaction.commandName === 'add_role_to_menu') {
        await addRoleToMenu(interaction);
    } else if (interaction.commandName === 'delete_role_from_menu') {
        await deleteRoleFromMenu(interaction);
    } else if (interaction.commandName === 'edit_role_menu') {
        await editRoleMenu(interaction);
    }
}

/*const buttonHandler = async (interaction) => {

}*/

const selectMenuHandler = async (interaction) => {
    if (interaction.customId === 'selectRole') {
        const guild = interaction.guild;
        const channel = interaction.channel;
        const message = interaction.message;
        const menu = await RoleMenu.findOne({
            guildID: guild.id,
            channelID: channel.id,
            messageID: message.id
        });
        if (interaction.values[0] != 'placeholder') {
            if (menu != null) {
                const roleIDs = menu.roles.map(role => role.roleID);
                roleIDs.forEach(roleID => interaction.member.roles.remove(roleID));
                interaction.member.roles.add(roleIDs[menu.roles.map(role => role.value).indexOf(interaction.values[0])]);
                await interaction.reply({content: 'You have received your role.', ephemeral: true});
            } else {
                await interaction.reply({content: 'Internal Error. Please contact admins.', ephemeral: true});
            }
        } else {
            await interaction.reply({
                content: 'This message does not have any roles yet. Please contact your administrator.',
                ephemeral: true
            });
        }
    }
}
module.exports = {
    slashCommandHandler,
    //buttonHandler,
    selectMenuHandler
}