const { Client, MessageEmbed, CommandInteraction, MessageActionRow, MessageSelectMenu, MessageButton } = require('discord.js')
const rrSchema = require("../../Structures/Schemas/ButtonRoles")

module.exports = {
    name: "roles-menu",
    description: "Create, delete Button Role Panels and add or remove roles from them",
    UserPerms: "MANAGE_GUILD",
    category: "Moderation",
    options: [
        {
            name: "create",
            description: "Creates a new Button Role Panel",
            type: "SUB_COMMAND",
            options: [
                {
                    name: "name",
                    description: "Provide the name of the Button Role Panel",
                    type: "STRING",
                    required: true
                },
                {
                    name: "description",
                    description: "Provide a short description about this panel",
                    type: "STRING",
                    required: false
                },
                {
                    name: "access-role",
                    description: "Select the role that can only get roles by selecting from the panel (Leave blank for @everyone)",
                    type: "ROLE",
                    required: false
                },
            ]
        },
        {
            name: "delete",
            description: "Deletes a Button Role Panel",
            type: "SUB_COMMAND",
            options: [
                {
                    name: "panel-id",
                    description: "Provide the Button Role Panel ID",
                    type: "STRING",
                    required: true
                },
            ]
        },
        {
            name: "list",
            description: "Lists all the active Button Role Panels",
            type: "SUB_COMMAND"
        },
        {
            name: "add",
            description: "Adds a new Button Role to the Panel",
            type: "SUB_COMMAND",
            options: [
                {
                    name: "panel-id",
                    description: "Provide the Button Role Panel ID",
                    type: "STRING",
                    required: true
                },
                {
                    name: "role",
                    description: "Select the role to be added",
                    type: "ROLE",
                    required: true
                },
                {
                    name: "emoji",
                    description: "Provide the emoji for the role",
                    type: "STRING",
                    required: false
                },
            ]
        },
        {
            name: "remove",
            description: "Removes An existing Button Role from the Panel",
            type: "SUB_COMMAND",
            options: [
                {
                    name: "panel-id",
                    description: "Provide the Button Role Panel ID",
                    type: "STRING",
                    required: true
                },
                {
                    name: "role",
                    description: "Select the role to be removed",
                    type: "ROLE",
                    required: true
                },
            ]
        },
        {
            name: "panel",
            description: "Sends the Button Role Panel",
            type: "SUB_COMMAND",
            options: [
                {
                    name: "panel-id",
                    description: "Provide the Button Role Panel ID",
                    type: "STRING",
                    required: true
                },
                {
                    name: "channel",
                    description: "Select the channel, where it should be send",
                    type: "CHANNEL",
                    channelTypes: ["GUILD_TEXT"],
                    required: false
                },
            ]
        },
    ],

    /**
     * @param {Client} client
     * @param {CommandInteraction} interaction
     */
    async execute(interaction, client) {

        const { options, guild, channel, user } = interaction

        switch (options.getSubcommand()) {

            case "create": {

                const name = options.getString("name").toLowerCase()
                const description = options.getString("description") || "Click on a button below to get the Specific Role"
                const role = options.getRole("access-role")

                const data = await rrSchema.findOne({ Guild: guild.id })

                if (!data) {

                    if (role) {

                        new rrSchema({

                            Guild: guild.id,
                            Description: description,
                            Role: role.id,
                            User: user.id,
                            Name: name,

                        }).save()

                    } else {

                        new rrSchema({

                            Guild: guild.id,
                            Description: description,
                            User: user.id,
                            Name: name,

                        }).save()

                    }

                } else {

                    if (data.Name.includes(name)) return interaction.reply({
                        embeds: [
                            new MessageEmbed()
                                .setColor("BLUE")
                                .setDescription(`${ErrorA} - A Button Role Panel already exists with the name **${name.toUpperCase()}**, please try a new one!`)
                        ],
                        ephemeral: true
                    })

                    if (role) {

                        new rrSchema({

                            Guild: guild.id,
                            Description: description,
                            Role: role.id,
                            User: user.id,
                            Name: name,

                        }).save()

                    } else {

                        new rrSchema({

                            Guild: guild.id,
                            Description: description,
                            User: user.id,
                            Name: name,

                        }).save()

                    }

                }

                interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${Tick} - A new Button Role Panel named **${name.toUpperCase()}** has been created by ${user}, use \`/roles-menu list\` to see the Panel ID`)
                    ]
                })

            }
                break;

            case "list": {

                const panelList = await rrSchema.find({ Guild: guild.id })

                if (!panelList?.length) return interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor('BLUE')
                            .setDescription(`${ErrorA} - There's no active Button Role Panel at this moment!`)
                    ],
                    ephemeral: true
                })

                let index = 1

                const panelData = panelList.map((data) => {

                    let Role

                    if (data.Role) Role = guild.roles.cache.get(data.Role)
                    else Role = "None"

                    return `\`${index++}.\` **Name:** ${data.Name.toUpperCase()}\n **ID:** \`${data._id}\`\n **Required Role:** ${Role}`

                }).join("\n\n")

                interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setTitle(`${CReaction} Button Panels of ${guild.name}`)
                            .setDescription(`${panelData}`)
                            .setThumbnail(guild.iconURL({ dynamic: true }))
                            .setFooter({ text: "Button Roles by Drago" })
                            .setTimestamp()
                    ]

                })

            }
                break;

            case "delete": {

                const panelID = options.getString("panel-id")

                const guildData = await rrSchema.findOne({ _id: panelID }).catch(err => { })

                if (!guildData) return interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${ErrorA} - Please provide a valid Panel ID!`)
                    ],
                    ephemeral: true
                })

                if (guild.id !== guildData.Guild) return interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${ErrorA} - You can't access a Button Roles Panel of another server!`)
                    ],
                    ephemeral: true
                })

                await guildData.delete()

                interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${Tick} - Deleted the Button Roles Panel associated to the ID: \`${panelID}\``)
                    ]

                })

            }
                break;

            case "add": {

                const panelID = options.getString("panel-id")
                const role = options.getRole("role")
                const emoji = options.getString("emoji") || "🟡"

                const guildData = await rrSchema.findOne({ _id: panelID }).catch(err => { })

                if (!guildData) return interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${ErrorA} - Please provide a valid Panel ID!`)
                    ],
                    ephemeral: true
                })

                if (guild.id !== guildData.Guild) return interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${ErrorA} - You can't access a Button Roles Panel of another server!`)
                    ],
                    ephemeral: true
                })

                if (guildData.Roles.length >= 25) return interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${ErrorA} - You can only add \`25\` roles to a particular panel!`)
                    ],
                    ephemeral: true
                })

                if (role.position >= guild.me.roles.highest.position) return interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${ErrorA} - I can't add a role that is higher or equal to me!`)
                    ],
                    ephemeral: true
                })

                const newRole = {
                    RoleID: role.id,
                    RoleEmoji: emoji
                }

                if (guildData) {

                    const roleData = guildData.Roles.find((r) => r.RoleID === role.id)

                    if (roleData) {

                        roleData = newRole

                    } else {

                        guildData.Roles = [...guildData.Roles, newRole]

                    }

                    await guildData.save()

                } else {

                    await rrSchema.create({
                        Guild: guild.id,
                        Roles: newRole
                    })

                }

                const Emoji = emoji

                interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setTitle("😁 Added To Panel")
                            .setDescription(`
                                **Panel Name:** ${guildData.Name.toUpperCase()}
                                **Role:** ${role}
                                **Emoji:** ${Emoji}
                            `)
                            .setTimestamp()
                            .setFooter({ text: "Button Roles by Drago" })
                            .setThumbnail(guild.iconURL({ dynamic: true }))
                    ]
                })

            }
                break;

            case "remove": {

                const panelID = options.getString("panel-id")
                const role = options.getRole("role")

                const guildData = await rrSchema.findOne({ _id: panelID }).catch(err => { })

                if (!guildData) return interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${ErrorA} - Please provide a valid Panel ID!`)
                    ],
                    ephemeral: true
                })

                if (guild.id !== guildData.Guild) return interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${ErrorA} - You can't access a Button Role Panel of another server!`)
                    ],
                    ephemeral: true
                })

                const guildRoles = guildData.Roles

                const findRole = guildRoles.find((r) => r.RoleID === role.id)

                if (!findRole) return interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${ErrorA} - This role was never added to this Button Role Panel!`)
                    ],
                    ephemeral: true
                })

                const filteredRoles = guildRoles.filter((r) => r.RoleID !== role.id)

                guildData.Roles = filteredRoles

                await guildData.save()

                interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${Tick} - Successfully removed ${role} from the Button Role Panel`)
                    ]
                })

            }
                break;

            case "panel": {

                const panelID = options.getString("panel-id")
                const Channel = options.getChannel("channel") || channel

                const guildData = await rrSchema.findOne({ _id: panelID }).catch(err => { })

                if (!guildData) return interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${ErrorA} - Please provide a valid Panel ID!`)
                    ],
                    ephemeral: true
                })

                if (guild.id !== guildData.Guild) return interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${ErrorA} - You can't access a Button Panel of another server!`)
                    ],
                    ephemeral: true
                })

                if (!guildData?.Roles) return interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${ErrorA} - Couldn't find any role data!`)
                    ],
                    ephemeral: true
                })

                const Description = guildData.Roles.map((x) => {

                    const role = guild.roles.cache.get(x.RoleID)

                    return `\`${x.RoleEmoji}\` ⭢ ${role}`

                }).join("\n")

                const Embed = new MessageEmbed()
                    .setColor("BLUE")
                    .setTitle(`${guildData.Name.toUpperCase()}`)
                    .setDescription(`${guildData.Description}\n\n${Description}`)
                    .setThumbnail(guild.iconURL({ dynamic: true }))
                    .setTimestamp()
                    .setFooter({ text: "Button Roles by Drago" })

                interaction.reply({
                    embeds: [
                        new MessageEmbed()
                            .setColor("BLUE")
                            .setDescription(`${Tick} - Sent the Button Role Panel to ${Channel}`)
                    ],
                    ephemeral: true
                })

                const row = panelRow(guildData.Roles, 5, guild)

                Channel.send({ embeds: [Embed], components: row })

            }
                break;

        }

    }
}

function panelRow(array, number, guild) {

    const Rows = []
    let k = number

    for (let i = 0; i < array.length; i += number) {

        const current = array.slice(i, k)

        k += number

        let TotalArray = []

        const Info = current.map((x) => {

            const role = guild.roles.cache.get(x.RoleID)

            return new MessageButton()
                .setStyle("SUCCESS")
                .setCustomId(role.id)
                .setLabel(role.name)
                .setEmoji(x.RoleEmoji)

        })

        TotalArray.push(Info)

        TotalArray.forEach(x => {

            const Row = new MessageActionRow().addComponents(x)

            Rows.push(Row)

        })

    }

    return Rows

}