index.js

import express from "express";
const app = express();

app.get("/", (_, res) => res.send("✅ Poll Bot is alive and running!"));
app.listen(process.env.PORT || 3000, () => {
  console.log(`🌐 Keep-alive web server running on port ${process.env.PORT || 3000}`);
});

import pkg from "discord.js";
const {
  Client,
  GatewayIntentBits,
  SlashCommandBuilder,
  ActionRowBuilder,
  ButtonBuilder,
  ButtonStyle,
  StringSelectMenuBuilder,
  EmbedBuilder,
} = pkg;

import dotenv from "dotenv";
dotenv.config();

const client = new Client({ intents: [GatewayIntentBits.Guilds] });

import fs from "fs";
const DATA_FILE = "./retreats.json";
const activities = new Map();

function saveState() {
  fs.writeFileSync(DATA_FILE, JSON.stringify(Object.fromEntries(activities), null, 2));
}

let saveTimeout;
function queueSave() {
  clearTimeout(saveTimeout);
  saveTimeout = setTimeout(saveState, 2000);
}

function loadState() {
  if (fs.existsSync(DATA_FILE)) {
    const data = JSON.parse(fs.readFileSync(DATA_FILE));
    for (const [id, state] of Object.entries(data)) activities.set(id, state);
  }
}

loadState();
console.log(`🗂 Loaded ${activities.size} retreats from ${DATA_FILE}`);

// ----------------- WAITLIST PROMOTION -----------------
async function promoteWaitlist(state, activityName, interaction) {
  const activity = state.data[activityName];
  if (!activity) return;

  if (activity.waitlist.length > 0 && activity.claimed.length < activity.capacity) {
    const promotedUserId = activity.waitlist.shift();
    activity.claimed.push(promotedUserId);

    const user = await client.users.fetch(promotedUserId);
    const dmMessage = `🎉 You’ve been **promoted** from the waitlist to **${activityName}** for **${state.title}**!`;

    try {
      await user.send(dmMessage);
    } catch {
      console.warn(`⚠️ Could not DM ${user.tag}`);
    }

    try {
      await interaction.followUp({
        content: `🎉 <@${promotedUserId}> has been promoted from waitlist to **${activityName}**!`,
        ephemeral: true,
      });
    } catch {
      console.warn("⚠️ Could not send ephemeral promotion follow-up.");
    }

    console.log(`🎯 Promoted ${promotedUserId} from waitlist to ${activityName}`);
    queueSave(); // ✅ Save after promotion
  }
}

// ----------------- READY -----------------
client.once("clientReady", async () => {
  console.log(`✅ Logged in as ${client.user.tag}`);

  const commands = [
    new SlashCommandBuilder()
      .setName("retreat")
      .setDescription("Create a claimable activity signup (first come, first served).")
      .addStringOption(o =>
        o.setName("title").setDescription("Title of the signup post").setRequired(true)
      )
      .addStringOption(o =>
        o
          .setName("activities")
          .setDescription("Activities as 'Name:Capacity, Name:Capacity'")
          .setRequired(true)
      ),
    new SlashCommandBuilder()
      .setName("retreat_close")
      .setDescription("Close an active retreat signup (disable buttons).")
      .addStringOption(o =>
        o
          .setName("message_id")
          .setDescription("Message ID of the signup post (optional if you want to select)")
          .setRequired(false)
      ),
    new SlashCommandBuilder()
      .setName("retreat_results")
      .setDescription("Show results for a retreat signup.")
      .addStringOption(o =>
        o
          .setName("message_id")
          .setDescription("Message ID of the signup post (optional if you want to select)")
          .setRequired(false)
      ),
  ];

  try {
    await client.application.commands.set(commands);
    console.log("🌍 Registered global slash commands!");
  } catch (err) {
    console.error("❌ Failed to register global commands:", err);
  }
});

// ----------------- MAIN INTERACTION HANDLER -----------------
client.on("interactionCreate", async interaction => {
  try {
    // ----- /retreat -----
    if (interaction.isChatInputCommand() && interaction.commandName === "retreat") {
      const title = interaction.options.getString("title");
      const list = interaction.options.getString("activities");

      const parsed = {};
      for (const part of list.split(",")) {
        const [name, capStr] = part.split(":").map(s => s.trim());
        const cap = parseInt(capStr);
        if (!name || isNaN(cap)) {
          return interaction.reply({
            content: "❌ Invalid format. Use 'Name:Capacity, Name:Capacity'",
            ephemeral: true,
          });
        }
        parsed[name] = cap;
      }

      const embed = new EmbedBuilder()
        .setTitle(title)
        .setDescription(
          "Click a button to choose your activity! You can only choose one activity at a time.\nUse **View Participants** to see all sign-ups."
        )
        .setColor(0x57f287);

      for (const [name, cap] of Object.entries(parsed)) {
        embed.addFields({ name: `${name} — 0/${cap}`, value: "_No one yet_", inline: false });
      }

      const claimRow = new ActionRowBuilder();
      for (const [name] of Object.entries(parsed)) {
        claimRow.addComponents(
          new ButtonBuilder()
            .setCustomId(`claim_${name}`)
            .setLabel(name)
            .setStyle(ButtonStyle.Primary)
        );
      }

      const viewRow = new ActionRowBuilder().addComponents(
        new ButtonBuilder()
          .setCustomId("view_participants")
          .setLabel("🔍 View Participants")
          .setStyle(ButtonStyle.Secondary)
      );

      await interaction.reply({
        embeds: [embed],
        components: [claimRow, viewRow],
      });

      const msg = await interaction.fetchReply();

      activities.set(msg.id, {
        title,
        data: Object.fromEntries(
          Object.keys(parsed).map(k => [k, { capacity: parsed[k], claimed: [], waitlist: [] }])
        ),
        closed: false,
      });
      queueSave(); // ✅ Save new retreat
      return;
    }

    // ----- /retreat_close -----
    if (interaction.isChatInputCommand() && interaction.commandName === "retreat_close") {
      const messageId = interaction.options.getString("message_id");

      if (!messageId) {
        const openPolls = Array.from(activities.entries()).filter(([_, v]) => !v.closed);

        if (openPolls.length === 0) {
          return interaction.reply({
            content: "✅ There are no open retreats to close!",
            ephemeral: true,
          });
        }

        const selectMenu = new StringSelectMenuBuilder()
          .setCustomId("close_select")
          .setPlaceholder("Select a retreat to close")
          .addOptions(
            openPolls.map(([id, v]) => ({
              label: v.title,
              description: `ID: ${id}`,
              value: id,
            }))
          );

        const row = new ActionRowBuilder().addComponents(selectMenu);

        return interaction.reply({
          content: "Select a retreat to close:",
          components: [row],
          ephemeral: true,
        });
      }

      const state = activities.get(messageId);
      if (!state)
        return interaction.reply({
          content: "❌ Could not find that retreat post (bot must still be running).",
          ephemeral: true,
        });

      const channel = await interaction.channel.fetch();
      const msg = await channel.messages.fetch(messageId);

      const disabledRows = msg.components.map(componentRow => {
        const newRow = new ActionRowBuilder();
        for (const btn of componentRow.components) {
          newRow.addComponents(ButtonBuilder.from(btn).setDisabled(true));
        }
        return newRow;
      });

      await msg.edit({ components: disabledRows });
      state.closed = true;
      queueSave(); // ✅ Save closure
      return interaction.reply({
        content: `🔒 **${state.title}** has been closed.`,
        ephemeral: true,
      });
    }

    // ----- CLOSE SELECTION -----
    if (interaction.isStringSelectMenu() && interaction.customId === "close_select") {
      const messageId = interaction.values[0];
      const state = activities.get(messageId);
      if (!state)
        return interaction.reply({
          content: "❌ That retreat could not be found.",
          ephemeral: true,
        });

      const channel = await interaction.channel.fetch();
      const msg = await channel.messages.fetch(messageId);

      const disabledRows = msg.components.map(componentRow => {
        const newRow = new ActionRowBuilder();
        for (const btn of componentRow.components) {
          newRow.addComponents(ButtonBuilder.from(btn).setDisabled(true));
        }
        return newRow;
      });

      await msg.edit({ components: disabledRows });
      state.closed = true;
      queueSave(); // ✅ Save closure
      return interaction.reply({
        content: `🔒 **${state.title}** has been closed.`,
        ephemeral: true,
      });
    }

    // ----- /retreat_results -----
    if (interaction.isChatInputCommand() && interaction.commandName === "retreat_results") {
      const messageId = interaction.options.getString("message_id");

      if (!messageId) {
        const openPolls = Array.from(activities.entries());
        if (openPolls.length === 0) {
          return interaction.reply({
            content: "📭 No retreats found to show results for.",
            ephemeral: true,
          });
        }

        const selectMenu = new StringSelectMenuBuilder()
          .setCustomId("results_select")
          .setPlaceholder("Select a retreat to view results")
          .addOptions(
            openPolls.map(([id, v]) => ({
              label: v.title,
              description: `ID: ${id}`,
              value: id,
            }))
          );

        const row = new ActionRowBuilder().addComponents(selectMenu);

        return interaction.reply({
          content: "Select a retreat to view results:",
          components: [row],
          ephemeral: true,
        });
      }

      const state = activities.get(messageId);
      if (!state)
        return interaction.reply({
          content: "❌ Could not find that signup post (bot may have been restarted).",
          ephemeral: true,
        });

      let report = `📊 **Results for ${state.title}:**\n\n`;
      for (const [name, info] of Object.entries(state.data)) {
        report += `**${name}** — ${info.claimed.length}/${info.capacity}\n`;
        if (info.claimed.length > 0)
          report += `• ${info.claimed.map(id => `<@${id}>`).join(", ")}\n`;
        if (info.waitlist.length > 0)
          report += `• Waitlist: ${info.waitlist.map(id => `<@${id}>`).join(", ")}\n`;
        report += "\n";
      }

      return interaction.reply({ content: report, ephemeral: true });
    }

    // ----- RESULTS SELECTION -----
    if (interaction.isStringSelectMenu() && interaction.customId === "results_select") {
      const messageId = interaction.values[0];
      const state = activities.get(messageId);
      if (!state)
        return interaction.reply({
          content: "❌ That retreat could not be found.",
          ephemeral: true,
        });

      let report = `📊 **Results for ${state.title}:**\n\n`;
      for (const [name, info] of Object.entries(state.data)) {
        report += `**${name}** — ${info.claimed.length}/${info.capacity}\n`;
        if (info.claimed.length > 0)
          report += `• ${info.claimed.map(id => `<@${id}>`).join(", ")}\n`;
        if (info.waitlist.length > 0)
          report += `• Waitlist: ${info.waitlist.map(id => `<@${id}>`).join(", ")}\n`;
        report += "\n";
      }

      return interaction.reply({ content: report, ephemeral: true });
    }

    // ----- BUTTONS -----
    if (interaction.isButton()) {
      const state = activities.get(interaction.message.id);
      if (!state)
        return interaction.reply({
          content: "⚠️ This signup expired.",
          ephemeral: true,
        });

      await interaction.deferReply({ ephemeral: true });

      // 🔍 View participants
      if (interaction.customId === "view_participants") {
        let report = `📋 **Participants for ${state.title}:**\n\n`;
        for (const [name, info] of Object.entries(state.data)) {
          report += `**${name}** — ${info.claimed.length}/${info.capacity}\n`;
          if (info.claimed.length > 0)
            report += `• Claimed: ${info.claimed.map(id => `<@${id}>`).join(", ")}\n`;
          if (info.waitlist.length > 0)
            report += `• Waitlist: ${info.waitlist.map(id => `<@${id}>`).join(", ")}\n`;
          report += "\n";
        }
        return interaction.editReply({ content: report });
      }

      const [_, activityName] = interaction.customId.split("_");
      if (state.closed)
        return interaction.editReply({ content: "🔒 This signup is closed." });

      const userId = interaction.user.id;
      for (const info of Object.values(state.data)) {
        info.claimed = info.claimed.filter(id => id !== userId);
        info.waitlist = info.waitlist.filter(id => id !== userId);
      }

      const act = state.data[activityName];
      if (!act) return interaction.editReply({ content: "Invalid activity." });

      let msg;
      if (act.claimed.length < act.capacity) {
        act.claimed.push(userId);
        msg = `✅ You chose **${activityName}** (slot ${act.claimed.length}/${act.capacity}).`;
      } else {
        act.waitlist.push(userId);
        msg = `⚠️ **${activityName}** is full. You're on the waitlist (${act.waitlist.length}).`;
      }

      // Promote if space opens
      for (const [name] of Object.entries(state.data)) {
        await promoteWaitlist(state, name, interaction);
      }

      const embed = EmbedBuilder.from(interaction.message.embeds[0]);
      const fields = Object.entries(state.data).map(([name, info]) => ({
        name: `${name} — ${info.claimed.length}/${info.capacity}${
          info.claimed.length >= info.capacity ? " (FULL)" : ""
        }`,
        value:
          info.claimed.length === 0 && info.waitlist.length === 0
            ? "_No one yet_"
            : "Use **View Participants**",
        inline: false,
      }));
      embed.setFields(fields);

      await interaction.message.edit({ embeds: [embed] });
      await interaction.editReply({ content: msg });
      queueSave(); // ✅ Save signup changes
    }
  } catch (err) {
    console.error("❌ Interaction error:", err);
  }
});

client.login(process.env.DISCORD_TOKEN);