// commands/setModeratorStatus.js
const { SlashCommandBuilder, EmbedBuilder, ButtonBuilder, ActionRowBuilder, ButtonStyle, PermissionFlagsBits, ChatInputCommandInteraction } = require('discord.js');
const db = require('../../../db/status');
const ExtendedClient = require('../../../class/ExtendedClient');

module.exports = {
    structure: new SlashCommandBuilder()
        .setName('setmoderatorstatus')
        .setDescription('Erstellt ein Embed zur Anzeige des Moderatorstatus.')
        .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),
    /**
     * @param {ExtendedClient} client 
     * @param {ChatInputCommandInteraction} interaction 
     */
    run: async (client, interaction) => {
        const teamRoleIds = {
            'Administration': ['827894055685586985'], // Rolle für Administration
            'Verifizierung': ['1251156119405985885'], // Rolle für Verifizierung
            'Text- und Voicemoderation': ['1251156238645985330'], // Rolle für Text- und Voicemoderation
            'Ticket Team': ['1251156419424555058'], // Rolle für Ticket Team
            'Event': ['1251155855618084864'], // Rolle für Event
            'Entwicklung': ['1251155986345889812'], // Rolle für Entwicklung
            'Social Media': ['1251155678819651675'] // Rolle für Social Media
        };

        const guild = interaction.guild;
        const allMembers = guild.members.cache;

        // Mitglieder in verschiedenen Kategorien gruppieren
        const categorizedMembers = {};
        for (const [category, roleIds] of Object.entries(teamRoleIds)) {
            categorizedMembers[category] = allMembers.filter(member => roleIds.some(roleId => member.roles.cache.has(roleId)));
        }

        const allowedRoleIDs = ['827894055685586985', '1251152367567638589']; // Erlaubte Rollen-IDs hier einfügen
        const allowedMemberIDs = ['580022368924336128', '401387927751491585']; // Erlaubte Mitglieder-IDs hier einfügen

        const member = interaction.member;
        const hasAllowedRoles = member.roles.cache.some(role => allowedRoleIDs.includes(role.id));
        const isAllowedMember = allowedMemberIDs.includes(interaction.user.id);

        if (!hasAllowedRoles && !isAllowedMember) {
            return interaction.reply({
                content: 'Du hast nicht die erforderlichen Rollen oder Berechtigungen, um diesen Befehl auszuführen.',
                ephemeral: true
            });
        }

        const updateEmbed = async () => {
            let fields = [];

            for (const [category, members] of Object.entries(categorizedMembers)) {
                let categoryDescription = '';
                for (const member of members.values()) {
                    await new Promise((resolve) => {
                        db.get("SELECT status, timestamp FROM statuses WHERE user_id = ?", [member.id], (err, row) => {
                            if (err) {
                                console.error(err);
                            } else {
                                const status = row ? row.status : 'Nicht stören';
                                const timestamp = row ? new Date(row.timestamp).toLocaleString() : 'N/A';
                                // Der Benutzer wird als Erwähnung dargestellt
                                categoryDescription += `<@${member.id}>:\n**Status:** ${status}\n**Zeit:** ${timestamp}\n\n`;
                            }
                            resolve();
                        });
                    });
                }
                if (categoryDescription) {
                    fields.push({
                        name: category,
                        value: categoryDescription || 'Keine Mitglieder gefunden.',
                        inline: false
                    });
                    fields.push({ name: '\u200B', value: '\u200B' }); // Fügt eine leere Zeile hinzu
                }
            }

            fields.push({
                name: 'Erklärungen der Status:',
                value: '**🟩 Anwesend:** Ich bin anwesend und erreichbar.\n' +
                      '**🟥 Nicht stören:** Ich bin anwesend, aber momentan beschäftigt.\n' +
                      '**⬜ Abgemeldet:** Ich bin abgemeldet und nicht erreichbar.',
                inline: false
            });

            const embed = new EmbedBuilder()
                .setTitle('Moderator Status')
                .addFields(fields)
                .setColor('Blurple')
                .setThumbnail(guild.iconURL({ dynamic: true }))

            return embed;
        };

        const embed = await updateEmbed();

        const row = new ActionRowBuilder()
            .addComponents(
                new ButtonBuilder()
                    .setCustomId('present')
                    .setLabel('Anwesend')
                    .setStyle(ButtonStyle.Success)
                    .setEmoji('🟩'),
                new ButtonBuilder()
                    .setCustomId('dnd')
                    .setLabel('Nicht stören')
                    .setStyle(ButtonStyle.Danger)
                    .setEmoji('🟥'),
                new ButtonBuilder()
                    .setCustomId('busy')
                    .setLabel('Abgemeldet')
                    .setStyle(ButtonStyle.Secondary)
                    .setEmoji('⬜')
            );

        const message = await interaction.reply({ embeds: [embed], components: [row], fetchReply: true });

        const filter = i => i.customId === 'present' || i.customId === 'busy' || i.customId === 'dnd';
        const collector = message.createMessageComponentCollector({ filter });

        collector.on('collect', async i => {
            if (!i.member.roles.cache.some(role => Object.values(teamRoleIds).flat().includes(role.id))) {
                return i.reply({ content: 'Du bist nicht berechtigt, diesen Button zu benutzen.', ephemeral: true });
            }

            let status;
            switch (i.customId) {
                case 'present':
                    status = 'Anwesend';
                    break;
                case 'busy':
                    status = 'Beschäftigt';
                    break;
                case 'dnd':
                    status = 'Nicht stören';
                    break;
            }
            const timestamp = Date.now();

            db.run("INSERT INTO statuses (user_id, status, timestamp) VALUES (?, ?, ?) ON CONFLICT(user_id) DO UPDATE SET status = ?, timestamp = ?", 
                [i.user.id, status, timestamp, status, timestamp], err => {
                if (err) {
                    console.error(err);
                }
            });

            const updatedEmbed = await updateEmbed();
            await i.update({ embeds: [updatedEmbed], components: [row] });
        });

        // Schedule updates every minute
        setInterval(async () => {
            const updatedEmbed = await updateEmbed();
            await message.edit({ embeds: [updatedEmbed] });
        }, 60000); // 60000ms = 1 minute
    }
};