const { MessageEmbed, Permissions, MessageActionRow, MessageButton } = require('discord.js');
const { black } = require('../../other/texts/colors.json');
const { performance } = require("perf_hooks");
const { warning } = require("../../other/texts/emojis.json");
 
// These are the models that we are going to be requiring to connect to the database.
const Ping = require("../../models/users/ping/ping.js");

module.exports = {
    config: {
        name: "ping",
        category: "utility",
        usage: "ping",
        description: "Displays Attitude's Ping.",
        accessableby: "Members"
    },
    run: async (bot, interaction) => {

        if (!interaction.channel.permissionsFor(interaction.guild.me).has([Permissions.FLAGS.VIEW_CHANNEL, Permissions.FLAGS.SEND_MESSAGES, Permissions.FLAGS.EMBED_LINKS])) return;

        let pinging = new MessageEmbed()
        .setColor(black)
        .setTitle("🏓 Attitude Ping")
        .addField("**API Latency**", `_ _`, true)
        .addField("**Message**", `_ _`, true)
        .addField("**Database**", `_ _`, true)
        .setFooter(`Responded across  servers.`)

        const msg = await interaction.channel.send({ embeds: [pinging] });
        msg.delete();

        Ping.findOne({
            userID: interaction.member.id,
        }, async (error, ping) => {
            if (error) console.log(error);
            if (!ping) {
                const newPing = new Ping({
                    userID: interaction.member.id
                });

                var now = performance.now();
                await newPing.save().catch(error => console.log(error));
            } else {
                var now = performance.now();
                await ping.save().catch(error => console.log(error));
            };

            let APILatencyPing = Math.floor(bot.ws.ping);
            let messagePing = Math.floor(msg.createdAt - interaction.createdAt);
            let databasePing = Math.floor(performance.now() - now);

            if (APILatencyPing > 650) APILatencyPing = `${warning} ${APILatencyPing}`;
            if (messagePing > 650) messagePing = `${warning} ${messagePing}`;
            if (databasePing > 100) databasePing = `${warning} ${databasePing}`;

            let embed = new MessageEmbed()
            .setColor(black)
            .setTitle("🏓 Attitude Ping")
            .addField("**API Latency**", `${APILatencyPing}ms`, true)
            .addField("**Message**", `${messagePing}ms`, true)
            .addField("**Database**", `${databasePing}ms`, true)
            .setFooter(`Responded across ${bot.guilds.cache.size} servers.`)

            const row = new MessageActionRow()
                .addComponents(
                    new MessageButton()
                        .setCustomId('reload')
                        .setLabel('Reload Ping')
                        .setStyle('PRIMARY')
                );

            const m = await interaction.followUp({ embeds: [embed], components: [row] });

            const filter = (int) => int.message.id === m.id && int.user.id === interaction.member.id;
            const collector = interaction.channel.createMessageComponentCollector({ filter, max: 10, componentType: 'BUTTON', time: 30000 });

            collector.on('collect', async (ButtonInteraction) => {
                if (!ButtonInteraction) {
                    row.components[0].setDisabled(true);
                    return interaction.editReply({ components: [row] });
                } else {
                    switch(ButtonInteraction.customId) {
                        case 'reload':
                            let recalculating = new MessageEmbed()
                            .setColor(black)
                            .setDescription("🏓 Recalculating...")

                            let before = Date.now();
                            let n = await interaction.channel.send({ embeds: [recalculating] });
                            let time = Date.now() - before;

                            n.delete();
                            
                            APILatencyPing = bot.ws.ping;
                            if (APILatencyPing > 650) APILatencyPing = `${warning} ${APILatencyPing}`;

                            if (time > 650) time = `${warning} ${time}`;

                            let reloaded = new MessageEmbed()
                            .setColor(black)
                            .setTitle("🏓 Attitude Ping")
                            .addField("**API Latency**", `${bot.ws.ping}ms`, true)
                            .addField("**Message**", `${time}ms`, true)
                            .addField("**Database**", `${databasePing}ms`, true)
                            .setFooter(`Responded across ${bot.guilds.cache.size} servers.`)

                            return await ButtonInteraction.update({ embeds: [reloaded] })
                            break;
                    };
                };
            });

            collector.on('end', async (ButtonInteraction) => {
                ButtonInteraction = ButtonInteraction.first();

                if (!ButtonInteraction) {
                    row.components[0].setDisabled(true);
                    return interaction.editReply({ components: [row] });
                } else {
                    row.components[0].setDisabled(true);
                    return ButtonInteraction.editReply({ components: [row] });
                };
            });
        })
    },
};