const { EmbedBuilder, Colors, ButtonStyle, ActionRowBuilder, ButtonBuilder, PermissionsBitField, ChannelType, PermissionFlagsBits } = require("discord.js");
const moment = require('moment');
const fetchAll = require('discord-fetch-all');
const fs = require('fs');
const mysql = require('mysql2');
const ownerId = ['917111527016898621'];
const { Events } = require('discord.js');

let sql;
const db = new mysql.createConnection({
    host: "localhost",
    user: "root",
    database: "database",
})

module.exports = {
	name: Events.InteractionCreate,
	once: true,
	async run(interaction) {

    if (interaction.isCommand()) {
        const cmd = interaction.client.commands.get(interaction.commandName);

        if (cmd) {
            try {
                if (cmd.ownerOnly && !ownerId.includes(interaction.user.id)) return await interaction.reply(`<:non:832737724619423825> Vous ne pouvez pas exécuter cette commande. | \`Développeurs seulement\` `);
                if (interaction.commandName == cmd.data.name) cmd.run(interaction);
            } catch {
                console.log(`Erreur dans la commande ${cmd.name}.`);
            };
        };
    };

        if (interaction.isButton()) {
            console.log('test')
            if (interaction.customId.startsWith('role')) {
                interaction.deferUpdate()

                const memberId = interaction.customId.split('_')[1]
                if (interaction.member.id != memberId) return;
                const filter = (u) => u.member.id === interaction.user.id;
                let u = await interaction.channel.send({ embeds: [new EmbedBuilder().setDescription('Mentionnez ci-dessous le rôle (Support) pour votre système de ticket ?').setColor(Colors.White)] })
                const collector = interaction.channel.createMessageCollector({ filter, max: 1, time: 15000 })
                    .on('collect', c => {
                        let msg = c.mentions.roles.first()
                        db.query(`SELECT * FROM setticket WHERE guild = ${interaction.guild.id}`, async (err, req) => {
                            if (!req[0]?.role) { db.query(`INSERT INTO setticket (guild, role) VALUES ('${interaction.guild.id}', '${msg.id}')`) }
                            if (req[0]?.role) { db.query(`UPDATE setticket SET role = ${msg.id} WHERE guild = ${interaction.guild.id}`); }
                        })
                        interaction.channel.send({ content: `<:oui:1107731554404413481> Le rôle qui sera configuré pour le système de ticket sera <@${msg}>` })
                        u.delete()
                        c.delete()
                        collector.stop()
                    })
                    
            } else if (interaction.customId.startsWith('config')) {
                interaction.deferUpdate()
                const row2 = new ActionRowBuilder()
                    .addComponents(
                        new ButtonBuilder()
                            .setCustomId(`send`)
                            .setStyle(ButtonStyle.Success)
                            .setLabel("Envoyer")
                    )


                const memberId = interaction.customId.split('_')[1]
                if (interaction.member.id != memberId) return;
                const filter = (u) => u.member.id === interaction.user.id;

                let u = await interaction.channel.send({ embeds: [new EmbedBuilder().setDescription(`Mentionnez ci-dessous le channel qui sera configurer pour votre système de ticket ?`, { ephemeral: true }).setColor(Colors.White)] })
                const collector = interaction.channel.createMessageCollector({ filter, max: 1, time: 15000 })
                    .on('collect', async c => {
                        let msg = c.mentions.channels.first()
                        db.query(`SELECT * FROM setticket WHERE guild = ${interaction.guild.id}`, async (err, req) => {
                            const guildId = interaction.guild.id;
                            const guild = client.guilds.cache.get(guildId);
                            const rolesWithAdminPermission = guild.roles.cache.filter(role => role.permissions.has(PermissionsBitField.Flags.ManageChannels));
                            const randomRole = rolesWithAdminPermission.random();
                            if (!req[0]?.role) {
                                db.query(`INSERT INTO setticket (guild, channelId, role) VALUES ('${interaction.guild.id}', '${msg.id}', '${randomRole.id}')`)
                                interaction.followUp({ content: `<:oui:1107731554404413481> Le channel qui sera configurer pour le système de ticket sera ${msg}.` }).then(msg => { setTimeout(() => { msg.delete() }, 5000) })
                                interaction.followUp({ content: `<:oui:1107731554404413481> Le rôle qui sera configurer automatiquement sera **${randomRole.name}**.` }).then(msg => { setTimeout(() => { msg.delete() }, 5000) })
                            } else {
                                db.query(`UPDATE setticket SET channelId = ${msg.id} WHERE guild = ${interaction.guild.id}`);
                                interaction.followUp({ content: `<:oui:1107731554404413481> Le channel qui sera configurer pour votre panel de ticket sera <#${msg.id}>` })
                            }
                        })
                        u.delete()
                        c.delete()
                        collector.stop()


                        let d = await interaction.channel.send({ embeds: [new EmbedBuilder().setDescription(`Indiquez ci-dessous l'ID de la catégorie où seront affiché les tickets ?`, { ephemeral: true }).setColor(Colors.White)] })
                        const collectord = interaction.channel.createMessageCollector({ filter, max: 1, time: 15000 })
                            .on('collect', async c => {
                                let msg = c.content
                                let channel = await interaction.guild.channels.cache.get(msg)
                                let category = interaction.guild.channels.cache.find(cat => cat.id === channel?.id)
                                if (channel?.id === channel?.parent) return interaction.followUp({ content: '<:non:1107733694887776266> Je ne trouve pas la catégorie sur votre serveur ! | `ID non valide` ' })
                                if (category.type !== ChannelType.GuildCategory) return interaction.followUp({ content: '<:non:1107733694887776266> Je ne trouve pas la catégorie sur votre serveur ! `ID channel détecté` ' })
                                db.query(`SELECT * FROM setticket WHERE guild = ${interaction.guild.id}`, async (err, req) => {
                                    db.query(`UPDATE setticket SET category = ${channel?.id} WHERE guild = ${interaction.guild.id}`);
                                })
                                interaction.followUp({ content: `<:oui:1107731554404413481> La catégorie qui sera configuré pour votre panel de ticket sera <#${channel?.id}>` })
                                d.delete()
                                c.delete()
                                collector.stop()

                                let f = await interaction.channel.send({ embeds: [new EmbedBuilder().setDescription(`Indiquez ci-dessous le titre où sera affiché votre panel pour vos tickets ?`, { ephemeral: true }).setColor(Colors.White)] })
                                const collectord = interaction.channel.createMessageCollector({ filter, max: 1, time: 15000 })
                                    .on('collect', async cc => {
                                        let msgg = cc.content
                                        db.query(`SELECT * FROM setticket WHERE guild = ${interaction.guild.id}`, async (err, req) => {
                                            db.query(`UPDATE setticket SET title = "${msgg}" WHERE guild = ${interaction.guild.id}`);
                                        })
                                        interaction.followUp({ content: `<:oui:1107731554404413481> Le titre qui sera configuré pour votre panel de ticket sera\n> ${msgg}` })
                                        f.delete()
                                        cc.delete()
                                        collector.stop()

                                        let i = await interaction.channel.send({ embeds: [new EmbedBuilder().setDescription(`Indiquez ci-dessous la description où sera affiché votre panel pour vos tickets ?`, { ephemeral: true }).setColor(Colors.White)] })
                                        const collectord = interaction.channel.createMessageCollector({ filter, max: 1, time: 15000 })
                                            .on('collect', async ccc => {
                                                let msggh = ccc.content
                                                db.query(`SELECT * FROM setticket WHERE guild = ${interaction.guild.id}`, async (err, req) => {
                                                    db.query(`UPDATE setticket SET descript = "${msggh}" WHERE guild = ${interaction.guild.id}`);
                                                })
                                                interaction.followUp({ content: `<:oui:1107731554404413481> La description qui sera configuré pour votre panel de ticket sera\n> ${msggh}` })
                                                i.delete()
                                                ccc.delete()
                                                collector.stop()

                                                interaction.followUp({ content: `<:oui:1107731554404413481> La configuration de votre panel pour vos tickets est terminé ! Souhaitez-vous l'envoyer ?`, components: [row2] })

                                            })

                                    })
                            })
                    })
            }
            const row3 = new ActionRowBuilder()
                .addComponents(
                    new ButtonBuilder()
                        .setCustomId(`ticketopen`)
                        .setStyle(ButtonStyle.Primary)
                        .setLabel("Ouvrir un ticket")
                )
            if (interaction.customId === 'send') {
                interaction.deferUpdate()

                db.query(`SELECT * FROM setticket WHERE guild = ${interaction.guild.id}`, async (err, req) => {
                    const channel = interaction.guild.channels.cache.get(req[0]?.channelId)

                    const descript = req[0]?.descript
                    const title = req[0]?.title

                    const embed = new EmbedBuilder()
                        .setTitle(`${title}`)
                        .setDescription(`${descript}`)
                        .setColor(Colors.White)
                    channel.send({ embeds: [embed], components: [row3] })
                })

            } else if (interaction.customId === 'ticketopen') {
                if (interaction.deferUpdate());
                const row = new ActionRowBuilder()
                    .addComponents(
                        new ButtonBuilder()
                            .setCustomId(`delete`)
                            .setStyle(ButtonStyle.Danger)
                            .setLabel("Supprimer")
                    )

                db.query(`SELECT * FROM setticket WHERE guild = ${interaction.guild.id}`, async (err, req) => {
                    db.query(`SELECT * FROM ticketmember WHERE member = ${interaction.user.id}`, async (err, req1) => {
                        let embed = new EmbedBuilder()
                            .setDescription(`Merci de bien vouloir patienter, le temps que votre ticket s'ouvre.`)
                        let md = await interaction.channel.send({ embeds: [embed] }).catch(async err => { if (!err) return; })

                        const rolesupport = req[0]?.role

                        let role = interaction.guild.roles.cache.find(r => r.id === rolesupport);
                        if (!role) return interaction.guild.roles.create({ name: "Support", permissions: PermissionsBitField.Flags.SendMessages });
                        let categoria = interaction.guild.channels.cache.find(c => c.name == `TICKET`);
                        if (!categoria) categoria = await interaction.guild.channels.create({ name: `TICKET`, type: ChannelType.GuildCategory, position: 1, parent: categoria })
                        let Support = [PermissionsBitField.Flags.ViewChannel, PermissionsBitField.Flags.SendMessages, PermissionsBitField.Flags.AttachFiles, PermissionsBitField.Flags.ReadMessageHistory, PermissionsBitField.Flags.AddReactions, PermissionsBitField.Flags.EmbedLinks, PermissionsBitField.Flags.ManageMessages, PermissionsBitField.Flags.MuteMembers, PermissionsBitField.Flags.ManageNicknames]

                        interaction.guild.channels.create({ 
                            name: `tickets-${interaction.user.id}`, type: ChannelType.GuildText, permissionOverwrites: [
                                {
                                    id: interaction.guild.id,
                                    deny: PermissionsBitField.Flags.ViewChannel
                                },
                                {
                                    id: interaction.user,
                                    allow: PermissionsBitField.Flags.ViewChannel
                                },
                                {
                                    id: role.id,
                                    allow: Support
                                }
                            ],
                            parent: categoria.id
                        }).then(async channel => {
                            md.delete()
                            interaction.followUp({ content: `Vous venez d'ouvrir un ticket, il est désormais ouvert <#${channel.id}>.`, ephemeral: true })
                            const m = await channel.send({ content: `${interaction.user} - (<@&${role.id}>)`, embeds: [new EmbedBuilder().setTitle(`${interaction.user.username} `).setDescription(`Merci d'avoir ouvert un ticket.\Merci indiquer la raison de l'ouverture de votre ticket ? Demande / Problème / Partenariat... `)], components: [row] })
                            db.query(`INSERT INTO ticketmember (member, channel) VALUES ('${interaction.user.id}', '${channel.id}')`)
                        })
                    })
                })
            }
            if (interaction.customId === 'delete') {
                interaction.deferUpdate()

                const hastebin = require('hastebin-paste');
                db.query(`SELECT * FROM ticketmember WHERE member = ${interaction.user.id}`, async (err, req) => {

                    const allMessages = await fetchAll.messages(interaction.channel, {
                        reverseArray: true,
                        userOnly: true,
                        botOnly: false,
                        pinnedOnly: false,
                    });
                    const results = allMessages.map(msg => `[${moment(msg.createdTimestamp).format("DD/MM/YYYY - hh:mm:ss a").replace("pm", "PM").replace("am", "AM")}] - ${msg.author.tag} - (${msg.author.id}) : ${msg.content}`).join('\n')
                    let options = {
                        server: 'https://haste.chaun14.fr/'
                    };

                    await interaction.channel.send(`Le ticket vient d'être fermé, fermeture prévue dans **5 secondes**. `).then(msg => {
                        hastebin(`Voici les logs du salon ${interaction.channel.name} - ${interaction.channel.id} sur le serveur ${interaction.guild.name}\nCes logs ont été demandés par ${interaction.user.username}\n\u200b\n` + results, options).then(url => {

                            interaction.user.send({ embeds: [new EmbedBuilder().setTitle(`${interaction.user.username}`).setDescription(`Vous venez de fermer un ticket sur **${interaction.guild.name}**. Voici une copie de votre [ticket](${url}).`)] })
                            fs.writeFile(`./${interaction.channel.id}_${interaction.user.id}`, results, () =>
                                setTimeout(function () {
                                    fs.unlink(`./${interaction.channel.id}_${interaction.user.id}`, (err) => {
                                        if (err) throw err;

                                    });
                                }, 1000))

                            db.query(`SELECT * FROM setlogs WHERE guild = ${interaction.guild.id}`, async (err, reqq) => {

                                const channeld = interaction.guild.channels.cache.get(reqq[0]?.channel)
                                if (!channeld) return;

                                const ticketTranscript = new MessageEmbed()
                                    .setColor('RED')
                                    .setThumbnail(interaction.user.displayAvatarURL({ dynamic: true }))
                                    .setDescription(`**${interaction.user.username}** viens de supprimer un ticket.\n\n📝 | Transcript : ${url}\n💬 | Le salon : ${interaction.channel.name}`)
                                    .setFooter({ text: `ID : ${interaction.user.id}` })
                                    .setTimestamp()
                                    .setAuthor({ name: interaction.user.tag, iconURL: interaction.user.displayAvatarURL({ dynamic: true }) })
                                return channeld.send({ files: [{ attachment: `./${interaction.channel.id}_${interaction.user.id}`, name: `log${interaction.channel.id}.txt` }], embeds: [ticketTranscript] })
                            })
                        })
                    })

                    setTimeout(() => {
                        db.query(`DELETE FROM ticketmember WHERE member = ${interaction.user.id}`)
                        interaction.channel.delete()
                    }, 5000)
                })
            }
        }
}
}