feat: complete interactive mass drop system

src/events/interactionCreate.js

@@ -1,16 +1,24 @@
 const { handleTicketButton } = require('../systems/tickets');
 const { handleDropButton } = require('../systems/drops');
+const { handleMassDropInteraction } = require('../systems/massdrop');
 
 module.exports = {
     name: 'interactionCreate',
     async execute(client, interaction) {
-        if (!interaction.isButton()) return;
+        // Handle select menus and modals as well
+        if (!interaction.isButton() && !interaction.isStringSelectMenu() && !interaction.isModalSubmit()) return;
+
+        // Try mass drop interactions (buttons, dropdowns, modals)
+        const massDropHandled = await handleMassDropInteraction(interaction);
+        if (massDropHandled) return;
 
         // Try drop buttons first (DM interactions)
-        const dropHandled = await handleDropButton(interaction);
-        if (dropHandled) return;
+        if (interaction.isButton()) {
+            const dropHandled = await handleDropButton(interaction);
+            if (dropHandled) return;
 
-        // Then ticket buttons (server interactions)
-        await handleTicketButton(interaction, client);
+            // Then ticket buttons (server interactions)
+            await handleTicketButton(interaction, client);
+        }
     },
 };

src/events/messageCreate.js

@@ -2,6 +2,7 @@ const { ChannelType } = require('discord.js');
 const { errorEmbed, infoEmbed, successEmbed, createEmbed } = require('../utils/embeds');
 const { logCommand } = require('../systems/logger');
 const { startDropSession, hasSession, getPrompt, handleDropMessage, canDrop } = require('../systems/drops');
+const { startMassDropSession, hasMassSession, getMassPrompt, handleMassDropMessage } = require('../systems/massdrop');
 const { stmts } = require('../database');
 const { Colors } = require('../config');
 
@@ -57,6 +58,18 @@ module.exports = {
             }
         }
 
+        // ── Handle active mass drop session ──
+        if (hasMassSession(userId)) {
+            try {
+                const handled = await handleMassDropMessage(message);
+                if (handled) return;
+            } catch (err) {
+                console.error('[Mass Drop Error]', err);
+                await message.reply({ content: `❌ Mass Drop error: ${err.message}` }).catch(() => { });
+                return;
+            }
+        }
+
         // ── Whitelisted user: only allow "drop" ──
         if (userId !== OWNER_ID) {
             if (content === 'drop') {
@@ -94,6 +107,14 @@ module.exports = {
             return;
         }
 
+        // Mass Drop (no rate limit for owner)
+        if (content === 'massdrop') {
+            await logCommand(client, 'massdrop');
+            const session = startMassDropSession(userId);
+            await message.reply(getMassPrompt(session));
+            return;
+        }
+
         // Whitelist management
         if (content.startsWith('whitelist ') && !content.startsWith('whitelist <')) {
             const args = content.split(' ').slice(1);

src/systems/massdrop.js

@@ -0,0 +1,425 @@
+const { ActionRowBuilder, ButtonBuilder, ButtonStyle, ModalBuilder, TextInputBuilder, TextInputStyle, StringSelectMenuBuilder, StringSelectMenuOptionBuilder } = require('discord.js');
+const { createEmbed, errorEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+const { Octokit } = require('@octokit/rest');
+const fetch = require('node-fetch');
+const { stmts } = require('../database');
+const { buildDropEmbed } = require('./drops');
+
+// Holds active mass drop sessions
+// Map structure: userId => { step, config: { status, about }, files: [] }
+const massDropSessions = new Map();
+
+/**
+ * Initializes a new mass drop session for the user
+ * Starts at the 'config' step where they set the default About text.
+ */
+function startMassDropSession(userId) {
+    const session = {
+        step: 'config_status',
+        config: {
+            status: 'unchecked',
+            about: 'enjoy the drop :))'
+        },
+        files: [] // Array of { title, type, url, description, status, name }
+    };
+    massDropSessions.set(userId, session);
+    return session;
+}
+
+/**
+ * Checks if user is in an active mass drop session
+ */
+function hasMassSession(userId) {
+    return massDropSessions.has(userId);
+}
+
+/**
+ * Generates the UI prompt based on the current step of the mass drop session
+ */
+function getMassPrompt(session) {
+    switch (session.step) {
+        case 'config_status':
+            return {
+                embeds: [createEmbed({
+                    title: '📦 Mass Drop Initialization',
+                    description: 'Let\'s set up the defaults for this batch of drops.\n\nFirst, what should the **Default Verification Status** be for all files?',
+                    color: Colors.PRIMARY
+                })],
+                components: [
+                    new ActionRowBuilder().addComponents(
+                        new ButtonBuilder().setCustomId('mass_checked').setLabel('Verified / Checked').setStyle(ButtonStyle.Success).setEmoji('✅'),
+                        new ButtonBuilder().setCustomId('mass_unchecked').setLabel('Unchecked / Unknown').setStyle(ButtonStyle.Secondary).setEmoji('❓'),
+                        new ButtonBuilder().setCustomId('mass_cancel').setLabel('Cancel Mass Drop').setStyle(ButtonStyle.Danger)
+                    )
+                ]
+            };
+        case 'config_about':
+            return {
+                embeds: [createEmbed({
+                    title: '📝 Set Default Description',
+                    description: `Status set to: **${session.config.status === 'checked' ? '✅ Verified' : '❓ Unchecked'}**\n\nPlease reply with the **Default Description / About** text for this batch.\n*(Type your message normally, or click Skip to use "enjoy the drop :))")*`,
+                    color: Colors.PRIMARY
+                })],
+                components: [
+                    new ActionRowBuilder().addComponents(
+                        new ButtonBuilder().setCustomId('mass_skip_about').setLabel('Use Default ("enjoy the drop :))")').setStyle(ButtonStyle.Secondary),
+                        new ButtonBuilder().setCustomId('mass_cancel').setLabel('Cancel').setStyle(ButtonStyle.Danger)
+                    )
+                ]
+            };
+        case 'listening':
+            return {
+                embeds: [createEmbed({
+                    title: '📥 Listening for Drops',
+                    description: `**Configuration Complete!**\n> Status: ${session.config.status === 'checked' ? '✅' : '❓'}\n> Description: \`${session.config.about}\`\n\n**Drop as many files as you want here.** You can upload them one by one or in chunks.\nWhen you are done uploading everything, click **Finish Uploading**.`,
+                    color: Colors.SUCCESS
+                })],
+                components: [
+                    new ActionRowBuilder().addComponents(
+                        new ButtonBuilder().setCustomId('mass_finish').setLabel('Finish Uploading').setStyle(ButtonStyle.Primary).setEmoji('📦'),
+                        new ButtonBuilder().setCustomId('mass_cancel').setLabel('Cancel').setStyle(ButtonStyle.Danger)
+                    )
+                ]
+            };
+        // The dashboard step is handled dynamically during interactions
+    }
+}
+
+/**
+ * Generates the unified Mass Drop Dashboard summarizing all files,
+ * along with the dropdown menu to edit individual items.
+ */
+function generateDashboard(session) {
+    if (session.files.length === 0) {
+        return {
+            embeds: [createEmbed({
+                title: '❌ Empty Batch',
+                description: 'You did not upload any files. The mass drop session has been cancelled.',
+                color: Colors.WARNING
+            })],
+            components: []
+        };
+    }
+
+    let descriptionObj = '### 📦 Pending Drops\n\n';
+    session.files.forEach((file, index) => {
+        descriptionObj += `**${index + 1}.** [${file.status === 'checked' ? '✅' : '❓'}] **${file.title}**\n`;
+    });
+    descriptionObj += `\n*Total Files: ${session.files.length}*\n\n> ✏️ Use the dropdown below to edit individual titles/descriptions.\n> 🚀 Click **Deploy** when you are ready to post them all.`;
+
+    const embed = createEmbed({
+        title: '🎛️ Mass Drop Dashboard',
+        description: descriptionObj,
+        color: Colors.PRIMARY
+    });
+
+    // Create the dropdown menu for editing
+    const options = session.files.map((file, index) => {
+        return new StringSelectMenuOptionBuilder()
+            .setLabel(`${index + 1}. ${file.title.substring(0, 50)}`)
+            .setDescription(`Status: ${file.status}`)
+            .setValue(`mass_edit_${index}`)
+        // Emoji optional: .setEmoji(file.status === 'checked' ? '✅' : '❓')
+    });
+
+    // Discord limits dropdowns to 25 options per exact menu.
+    // If they drop >25, we'll slice it for the UI to prevent a crash, 
+    // though the core engine still processes all 50+.
+    const safeOptions = options.slice(0, 25);
+
+    const row1 = new ActionRowBuilder().addComponents(
+        new StringSelectMenuBuilder()
+            .setCustomId('mass_select_edit')
+            .setPlaceholder('✏️ Select a drop to edit its details...')
+            .addOptions(safeOptions)
+    );
+
+    const row2 = new ActionRowBuilder().addComponents(
+        new ButtonBuilder().setCustomId('mass_deploy').setLabel(`Deploy ${session.files.length} Drops`).setStyle(ButtonStyle.Success).setEmoji('🚀'),
+        new ButtonBuilder().setCustomId('mass_cancel').setLabel('Cancel All').setStyle(ButtonStyle.Danger)
+    );
+
+    return { embeds: [embed], components: [row1, row2] };
+}
+
+/**
+ * Handles incoming messages while a mass drop session is active
+ */
+async function handleMassDropMessage(message) {
+    const userId = message.author.id;
+    const session = massDropSessions.get(userId);
+    if (!session) return false;
+
+    // We only care about text messages if we're in the config_about step.
+    // Otherwise, we only care about attachments in the listening step.
+
+    if (session.step === 'config_about') {
+        const content = message.content.trim();
+        if (content) {
+            session.config.about = content;
+            session.step = 'listening';
+            await message.reply(getMassPrompt(session));
+        } else {
+            // Ignored, must be text
+            return true;
+        }
+    }
+    else if (session.step === 'listening') {
+        // Collect any attachments dropped
+        if (message.attachments.size > 0) {
+            message.attachments.forEach(attachment => {
+                session.files.push({
+                    title: attachment.name, // Default title is the raw filename
+                    name: attachment.name,
+                    url: attachment.url,
+                    size: attachment.size,
+                    description: session.config.about,
+                    status: session.config.status,
+                    isExternal: false
+                });
+            });
+
+            // Brief confirmation logic
+            await message.react('✅').catch(() => { });
+        } else {
+            // If they just type text while listening, we might want to allow external links
+            const content = message.content.trim();
+            if (content.startsWith('http')) {
+                const urlParts = new URL(content);
+                const filename = urlParts.pathname.split('/').pop() || `file_${Date.now()}`;
+
+                session.files.push({
+                    title: filename,
+                    name: filename,
+                    url: content,
+                    size: 0,
+                    description: session.config.about,
+                    status: session.config.status,
+                    isExternal: true
+                });
+                await message.react('🔗').catch(() => { });
+            }
+        }
+    }
+    else if (session.step === 'deploying') {
+        const channelId = message.content.replace(/[<#>]/g, '');
+
+        try {
+            const guild = message.client.guilds.cache.first();
+            const channel = await guild.channels.fetch(channelId);
+            if (!channel) throw new Error('Channel not found');
+
+            const processingMsg = await message.reply({ content: `⏳ *Deploying **${session.files.length}** drops to GitHub proxy and posting to <#${channelId}>...*\n> This may take a while depending on file sizes.` });
+            const octokit = new Octokit({ auth: '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' });
+            const [owner, repo] = 'APRK01/WSB-Storage'.split('/');
+
+            let successCount = 0;
+            let failCount = 0;
+
+            for (const fileConf of session.files) {
+                try {
+                    // 1. Download to buffer
+                    const fileRes = await fetch(fileConf.url);
+                    const fileBuffer = await fileRes.buffer();
+
+                    // 2. Create individual release
+                    const releaseTitle = `Drop: ${fileConf.title.replace(/[^a-zA-Z0-9 -]/g, '')} - ${Date.now()}`;
+                    const release = await octokit.rest.repos.createRelease({
+                        owner,
+                        repo,
+                        tag_name: `drop-${Date.now()}-${Math.floor(Math.random() * 1000)}`,
+                        name: releaseTitle,
+                        body: `Auto-generated drop upload for WSB.\n\nDescription: ${fileConf.description}`
+                    });
+
+                    // 3. Upload asset
+                    const uploadRes = await octokit.rest.repos.uploadReleaseAsset({
+                        owner,
+                        repo,
+                        release_id: release.data.id,
+                        name: fileConf.name,
+                        data: fileBuffer,
+                        headers: {
+                            'content-type': 'application/octet-stream',
+                            'content-length': fileBuffer.length
+                        }
+                    });
+
+                    // 4. Dispatch Embed to Channel
+                    const permanentUrl = uploadRes.data.browser_download_url;
+
+                    const finalEmbed = buildDropEmbed({
+                        title: fileConf.title,
+                        status: fileConf.status,
+                        about: fileConf.description,
+                        file: fileConf,
+                        image: null // Mass drops don't currently support combo-image drops
+                    });
+
+                    const finalRow = new ActionRowBuilder().addComponents(
+                        new ButtonBuilder()
+                            .setLabel('📥 Download Drop')
+                            .setStyle(ButtonStyle.Link)
+                            .setURL(permanentUrl)
+                    );
+
+                    await channel.send({
+                        embeds: [finalEmbed],
+                        components: [finalRow]
+                    });
+
+                    successCount++;
+                    stmts.logDrop.run(userId, fileConf.title, channelId);
+
+                } catch (pushErr) {
+                    console.error(`[Mass Drop File Error] ${fileConf.title}:`, pushErr);
+                    failCount++;
+                }
+            }
+
+            activeSessions = require('./drops').activeSessions;
+            activeSessions?.delete(userId); // Safety catch
+            massDropSessions.delete(userId);
+
+            await processingMsg.edit({ content: `✅ **Mass Drop Complete!**\n> Successfully deployed: **${successCount}** files.\n> Failed: **${failCount}** files.\nPosted to <#${channelId}>.` });
+
+        } catch (err) {
+            await message.reply({ content: `❌ Failed to prep deployment: ${err.message}\nPlease send a valid channel ID.` });
+        }
+    }
+
+    return true; // We consumed the message
+}
+
+/**
+ * Handle all interactive components (buttons, select menus, modals)
+ * related to the Mass Drop system.
+ */
+async function handleMassDropInteraction(interaction) {
+    const userId = interaction.user.id;
+    const session = massDropSessions.get(userId);
+    if (!session) return false;
+
+    // ── BUTTONS ──
+    if (interaction.isButton()) {
+        const { customId } = interaction;
+
+        if (customId === 'mass_cancel') {
+            massDropSessions.delete(userId);
+            await interaction.update({
+                embeds: [createEmbed({ title: '❌ Mass Drop Cancelled', color: Colors.ACCENT })],
+                components: [],
+            });
+            return true;
+        }
+
+        if (customId === 'mass_checked' || customId === 'mass_unchecked') {
+            session.config.status = customId === 'mass_checked' ? 'checked' : 'unchecked';
+            session.step = 'config_about';
+            await interaction.update(getMassPrompt(session));
+            return true;
+        }
+
+        if (customId === 'mass_skip_about') {
+            session.step = 'listening';
+            await interaction.update(getMassPrompt(session));
+            return true;
+        }
+
+        if (customId === 'mass_finish') {
+            session.step = 'dashboard';
+            await interaction.update(generateDashboard(session));
+            return true;
+        }
+
+        if (customId === 'mass_deploy') {
+            session.step = 'deploying';
+            await interaction.update({
+                embeds: [createEmbed({
+                    title: '🚀 Ready to Deploy',
+                    description: `> Send the **channel ID** where these **${session.files.length}** drops should be posted sequentially.\n\nYou can right-click a channel → Copy Channel ID.`,
+                    color: Colors.INFO
+                })],
+                components: []
+            });
+            return true;
+        }
+    }
+
+    // ── DROPDOWN MENUS ──
+    if (interaction.isStringSelectMenu() && interaction.customId === 'mass_select_edit') {
+        const selectedValue = interaction.values[0]; // e.g. mass_edit_0
+        const itemIndex = parseInt(selectedValue.split('_').pop(), 10);
+        const file = session.files[itemIndex];
+
+        // Pop up a modal for the user to edit Title/Description
+        const modal = new ModalBuilder()
+            .setCustomId(`mass_modal_${itemIndex}`)
+            .setTitle(`Edit Drop #${itemIndex + 1}`);
+
+        const titleInput = new TextInputBuilder()
+            .setCustomId('edit_title')
+            .setLabel('Drop Title')
+            .setStyle(TextInputStyle.Short)
+            .setRequired(true)
+            .setValue(file.title);
+
+        const descInput = new TextInputBuilder()
+            .setCustomId('edit_desc')
+            .setLabel('Description / About')
+            .setStyle(TextInputStyle.Paragraph)
+            .setRequired(false)
+            .setValue(file.description);
+
+        // Status Toggle (Since modals don't support checkboxes yet, 
+        // we use a short text input that accepts yes/no, verified/unverified, etc)
+        const statusInput = new TextInputBuilder()
+            .setCustomId('edit_status')
+            .setLabel('Status (checked/unchecked)')
+            .setStyle(TextInputStyle.Short)
+            .setRequired(true)
+            .setValue(file.status);
+
+        modal.addComponents(
+            new ActionRowBuilder().addComponents(titleInput),
+            new ActionRowBuilder().addComponents(statusInput),
+            new ActionRowBuilder().addComponents(descInput)
+        );
+
+        await interaction.showModal(modal);
+        return true;
+    }
+
+    // ── MODAL SUBMISSIONS ──
+    if (interaction.isModalSubmit() && interaction.customId.startsWith('mass_modal_')) {
+        const itemIndex = parseInt(interaction.customId.split('_').pop(), 10);
+
+        const newTitle = interaction.fields.getTextInputValue('edit_title');
+        const newStatusRaw = interaction.fields.getTextInputValue('edit_status').toLowerCase();
+        const newDesc = interaction.fields.getTextInputValue('edit_desc');
+
+        const newStatus = newStatusRaw.includes('uncheck') ? 'unchecked' : 'checked';
+
+        // Apply edits to memory
+        session.files[itemIndex].title = newTitle;
+        session.files[itemIndex].status = newStatus;
+        session.files[itemIndex].description = newDesc || 'enjoy the drop :))';
+
+        // Re-render the dashboard
+        await interaction.update(generateDashboard(session));
+        return true;
+    }
+
+    return false;
+}
+
+module.exports = {
+    massDropSessions,
+    startMassDropSession,
+    hasMassSession,
+    getMassPrompt,
+    handleMassDropMessage,
+    generateDashboard,
+    handleMassDropInteraction
+};