const Discord = require("discord.js")
const db = require("quick.db")
module.exports.run = async(bot, message, args) =>{
    if(!args[1] === "delete"){
        if(!args[2])return message.channel.send(`${bot.emoji.error} ${bot.prefix}rolemenu delete <name>`);
        let alreadyactived = await bot.rolemenu.fetch(`Rolemenu : ${message.guild.id} ${args[2]}`)
        if(!alreadyactived)return message.channel.send(`Aucun autorole ne porte se nom`);
        bot.rolemenu.delete(`Rolemenu : ${message.guild.id} ${args[2]}`)
        message.channel.send(`L'autorole ${args[2]} à été delete`);
    } 
    if(!args[1]) return message.channel.send(`${bot.emoji.error} ${bot.prefix}rolemenu <name>`)
    if(!args[1] === "delete")return;
    let alreadyactived = await bot.rolemenu.fetch(`Rolemenu : ${message.guild.id} ${args[1]}`)
    if(alreadyactived) return message.channel.send(`${bot.emoji.error} Un autorole existe déjà sous le nom de \`${args[1]}\``)
    let channelid = await bot.rolemenu.fetch(`Rolemenu : ${message.guild.id} ${args[1]}`, {target: '.channel'})
    let channelmention = message.guild.channels.cache.get(channelid)
//    let channeloui = `<#${channelmention.id}>`
    const embedbase = new Discord.MessageEmbed()
    embedbase.setTitle(`Rolemenu`)
    embedbase.addFields(
    {name: '**Salon**', value: channelmention? channelmention:'None', inline: true},
    {name: '**Message**', value: 'None', inline: true},
    {name: '**Rôle**', value: 'None', inline: true},
    {name: '**Reaction**', value: 'None', inline: true})
    
    let embedchargement = new Discord.MessageEmbed()
    .setTitle(`${bot.emoji.loading} Chargement...`);
    let msgg = await message.channel.send(embedbase)
    let msg = await message.channel.send(embedchargement)
    const embed = new Discord.MessageEmbed()

    embed.setTitle("Menu création d'autorole !")
    embed.setTimestamp()
    embed.setColor("BLACK")
    embed.setFooter(bot.footer1)

    embed.addFields(
        { name: '`🏷️`', value: '・Changer le salon', inline: true },
        { name: '`⤴️`', value: '・Utiliser le dernier message du salon', inline: true }, //message.channel.lastMessageID
        { name: '`🆔`', value: '・Choisir l\'ID d\'un message', inline: true },
        { name: '`🎭`', value: '・Choisir le role', inline: true },
        { name: '`❌`', value: '・Permet d\'annuler l\'embed', inline: true },
        { name: '`✅`', value: '・Permet d\'envoyer l\'embed avec le bot', inline: true },

    )

    await msg.react('🏷️')
    await msg.react('⤴️')
    await msg.react('🆔')
    await msg.react('🎭')
    await msg.react('❌')
    await msg.react('✅').then(async (m) => {

    msg.edit(" ", embed)

        let collector = msg.createReactionCollector((reaction, user) => user.id === message.author.id);
        collector.on("collect", async (reaction, user) => {
            if (reaction._emoji.name === "🏷️") {
                let question = await message.channel.send("Veuillez envoyé le salon du message")
                const filter = m => message.author.id === m.author.id;
                message.channel.awaitMessages(filter, {
                    max: 1,
                    time: 60000,
                    errors: ['time']
                }).then(async (collected) => {
                    collected.first().delete()
                    question.delete()
                    let channelrole = message.guild.channels.cache.find((r) => r.name ==  collected.first().content) ||
                    message.guild.channels.cache.find((r) => r.id == collected.first().content) ||
                    collected.first().mentions.channels.first()
                     if(!channelrole) return message.reply(`${bot.emoji.error} Channel Invalid`)
                    await bot.rolemenu.set(`Rolemenu : ${message.guild.id} ${args[1]}`, {channel: channelrole.id})
                    embedbase.fields.find(m => m.name === "**Salon**").value = '<#'+channelrole.id+'>'
                    msgg.edit(embedbase)
                    }).catch(async (err) => {
                        console.log(err)
                        collected.first().delete()
                        message.channel.send("Je n'ai pas pu modifier le salon").then((mm) => mm.delete({
                            timeout: 5000
                    }));
                })
            }

            if (reaction._emoji.name === "⤴️") {
                let question = await message.channel.send("Veuillez entrer `oui` pour activer le dernier message du salon")
                const filter = m => message.author.id === m.author.id;
                message.channel.awaitMessages(filter, {
                    max: 1,
                    time: 60000,
                    errors: ['time']
                }).then(async (collected) => {
                    collected.first().delete()
                    question.delete()
                    if(collected.first().content !== "oui") return;
             
                    question.delete()
                    let messageoui = await bot.rolemenu.fetch(`Rolemenu : ${message.guild.id} ${args[1]}`, {target: '.channel'})
                    let channeloui1 = message.guild.channels.cache.get(messageoui)
                    await bot.rolemenu.set(`Rolemenu : ${message.guild.id}`, {message: channeloui1.lastMessageID})
                    embedbase.fields.find(m => m.name === "**Message**").value = 'Dernier message du Salon'
                    msgg.edit(embedbase)
                    }).catch(async (err) => {
                        console.log(err)
                        collected.first().delete()
                        message.channel.send("Je n'ai pas pu activé le dernier message du salon ").then((mm) => mm.delete({
                            timeout: 5000
                    }));
                })
            }

            if (reaction._emoji.name === "🆔") {
                let question = await message.channel.send("Veuillez entrer l'ID du message")
                const filter = m => message.author.id === m.author.id;
                message.channel.awaitMessages(filter, {
                    max: 1,
                    time: 60000,
                    errors: ['time']
                }).then(async (collected) => {
                    let idmessage = collected.first().content
                    collected.first().delete()
                    question.delete()
                    let messageoui = await bot.rolemenu.fetch(`Rolemenu : ${message.guild.id} ${args[1]}`, {target: '.channel'})
                    let channeloui = message.guild.channels.cache.get(messageoui)
                    let messagerole = await channeloui.fetch(message.id === idmessage)
                   if(!messagerole){
                       let mes = await message.channel.send("Invalid ID")
                       mes.delete({timeout: 2000})
                   }
                    await bot.rolemenu.set(`Rolemenu : ${message.guild.id}`, {message: messagerole.id})
                    embedbase.fields.find(m => m.name === "**Message**").value = `${collected.first().content}`
                    msgg.edit(embedbase)
                    }).catch(async (err) => {
                        console.log(err)
                        collected.first().delete()
                        message.channel.send("Je n'ai pas pu modifier le message").then((mm) => mm.delete({
                            timeout: 5000
                    }));
                })
            }
            
            if (reaction._emoji.name === "🎭") {
                let question = await message.channel.send("Veuillez envoyé le role donné")
                const filter = m => message.author.id === m.author.id;
                message.channel.awaitMessages(filter, {
                    max: 1,
                    time: 60000,
                    errors: ['time']
                }).then(async (collected) => {
                    collected.first().delete()
                    question.delete()
                    let rolerole = message.guild.roles.cache.find((r) => r.name ==  collected.first().content) ||
                    message.guild.roles.cache.find((r) => r.id == collected.first().content) ||
                    collected.first().mentions.roles.first()
                     if(!rolerole) return message.reply(`${bot.emoji.error} Role Invalid`)
                    await bot.rolemenu.set(`Rolemenu : ${message.guild.id} ${args[1]}`, {role: rolerole.id})
                    embedbase.fields.find(m => m.name === "**Rôle**").value = '<@&'+rolerole.id+'>'
                    msgg.edit(embedbase)
                    let question1 = await message.channel.send("Veuillez envoyé l'id de la reaction du role")
                    const filter = m => message.author.id === m.author.id;
                    message.channel.awaitMessages(filter, {
                        max: 1,
                        time: 60000,
                        errors: ['time']
                    }).then(async (collected) => {
                        collected.first().delete()
                        question1.delete()
                        let emojiid = collected.first().content
                        let emojirole = message.guild.emojis.cache.get(emojiid)
                        if(!emojirole) return message.channel.send("Emoji incorect, l'émoji doit être dans le serveur ")
                        await bot.rolemenu.set(`Rolemenu : ${message.guild.id} ${args[1]}`, {reaction: emojirole.id})
                        embedbase.fields.find(m => m.name === "**Reaction**").value = emojirole
                        msgg.edit(embedbase)
                        })
                    }).catch(async (err) => {
                        console.log(err)
                        collected.first().delete()
                        message.channel.send("Je n'ai pas pu modifier le role ou la reaction").then((mm) => mm.delete({
                            timeout: 5000
                    }));
                })
            }

            if (reaction._emoji.name === "✅") {
                let question = await message.channel.send("Envoyé `oui` pour appliqué l'autorole")

                const filter = m => message.author.id === m.author.id;
                message.channel.awaitMessages(filter, {
                    max: 1,
                    time: 60000,
                    errors: ['time']
                }).then(async (collected) => {
                    collected.first().delete()
                    question.delete()
                    if(collected.first().content !== "oui") return;
                    let emojiid = await bot.rolemenu.fetch(`Rolemenu : ${message.guild.id} ${args[1]}`, {target: '.reaction'})
                    let emojirole = message.guild.emojis.cache.get(emojiid)
                    let channelid = await bot.rolemenu.fetch(`Rolemenu : ${message.guild.id} ${args[1]}`, {target: '.channel'})
                    let messageid = await bot.rolemenu.fetch(`Rolemenu : ${message.guild.id} ${args[1]}`, {target: '.message'})
                    let channeloui = message.guild.channels.cache.get(channelid)
                    let messagerole = channeloui.messages.cache.get(messageid)
                        messagerole.react(emojirole)
                
                    
                 

                }).catch(async (err) => {
                        console.log(err)
                        bot.rolemenu.delete(`Rolemenu : ${message.guild.id} ${args[1]}`)
                        message.channel.send("Je n'ai pas pu appliqué l'autorole").then((mm) => mm.delete({
                            timeout: 5000
                    }));
                })
            }


            if (reaction._emoji.name === "❌") {
                bot.rolemenu.delete(`Rolemenu : ${message.guild.id} ${args[1]}`)
                msg.delete()
                msgg.delete()
            }
            await reaction.users.remove(message.author.id);
        })
    });

 }
module.exports.admin = {
    name: "rolemenu"
}