trivia: quick refactor

commands/fun/trivia.js

@@ -10,118 +10,48 @@ const ongoingTrivia = new Set(); // Track users with ongoing trivia
 
 let lastApiCall = 0;
 
-module.exports = {
+const CATEGORY_MAP = {
-  data: new SlashCommandBuilder()
+  15: "Video Games",
-    .setName("trivia")
+  31: "Anime & Manga",
-    .setDescription("Play a trivia game")
+  18: "Computers",
-    .addStringOption((option) =>
+  16: "Board Games",
-      option
+  29: "Comics",
-        .setName("category")
+  32: "Cartoons & Animations",
-        .setDescription("Choose a trivia category")
+  11: "Film",
-        .setRequired(true)
+  9: "General Knowledge",
-        .addChoices(
+  17: "Science & Nature",
-          { name: "General Knowledge", value: "9" },
+  27: "Animals",
-          { name: "Video Games", value: "15" },
+  12: "Music",
-          { name: "Anime & Manga", value: "31" },
+  23: "History",
-          { name: "Computers", value: "18" },
+  22: "Geography",
-          { name: "Board Games", value: "16" },
+  20: "Mythology",
-          { name: "Comics", value: "29" },
+};
-          { name: "Cartoons & Animations", value: "32" },
-          { name: "Film", value: "11" },
-          { name: "Science & Nature", value: "17" },
-          { name: "Animals", value: "27" },
-          { name: "Music", value: "12" },
-          { name: "History", value: "23" },
-          { name: "Geography", value: "22" },
-          { name: "Mythology", value: "20" }
-        )
-    ),
-
-  async execute(interaction, client) {
-    const userId = interaction.user.id;
-    const username = interaction.user.username;
-    const guild = interaction.guild;
-    const timeLimit = 30000; // Time limit for answering in milliseconds
-
-    // Check if the user already has an ongoing trivia game
-    if (ongoingTrivia.has(userId)) {
-      return interaction.reply({
-        content:
-          "You already have an ongoing trivia game. Please finish it before starting a new one.",
-        ephemeral: true, // Only visible to the user
-      });
-    }
-
-    // Add the user to the set of active trivia players
-    ongoingTrivia.add(userId);
 
+const fetchTriviaQuestion = async (categoryId, categoryName) => {
   try {
-      const categoryId = interaction.options.getString("category");
-      const categoryName = (() => {
-        switch (categoryId) {
-          case "15":
-            return "Video Games";
-          case "31":
-            return "Anime & Manga";
-          case "18":
-            return "Computers";
-          case "16":
-            return "Board Games";
-          case "29":
-            return "Comics";
-          case "32":
-            return "Cartoons & Animations";
-          case "11":
-            return "Film";
-          case "9":
-            return "General Knowledge";
-          case "17":
-            return "Science & Nature";
-          case "27":
-            return "Animals";
-          case "12":
-            return "Music";
-          case "23":
-            return "History";
-          case "22":
-            return "Geography";
-          case "20":
-            return "Mythology";
-          default:
-            return "Video Games";
-        }
-      })()
-        .replace(/[^a-zA-Z0-9 &]/g, "")
-        .trim(); // Remove special characters and trim the category name for MongoDB query purposes in the Emebed title
-
-      // Fetch a trivia question from the cache or the API
     let triviaQuestion = await TriviaQuestion.findOne({
-        last_served: { $lt: new Date(Date.now() - QUESTION_EXPIRY) }, // Fetch questions not served recently
+      last_served: { $lt: new Date(Date.now() - QUESTION_EXPIRY) },
-        category: categoryName, // Filter by category
+      category: categoryName,
     }).sort({ last_served: 1 });
 
     if (!triviaQuestion || Date.now() - lastApiCall >= API_INTERVAL) {
-        // Fetch a new trivia question from OTDB
       const response = await axios.get(
         `https://opentdb.com/api.php?amount=1&category=${categoryId}`
       );
-
       triviaQuestion = response.data.results[0];
       lastApiCall = Date.now();
 
-        // Save the new trivia question to MongoDB
       await TriviaQuestion.create({
         question: decode(triviaQuestion.question),
         correct_answer: decode(triviaQuestion.correct_answer),
         incorrect_answers: triviaQuestion.incorrect_answers.map(decode),
-          category: categoryName, // Include the category
+        category: categoryName,
-          last_served: null, // Initially not served
+        last_served: null,
       });
 
-        // Fetch the newly created question
       triviaQuestion = await TriviaQuestion.findOne({
         question: decode(triviaQuestion.question),
-          category: categoryName, // Filter by category
+        category: categoryName,
       });
     }
 
@@ -130,31 +60,21 @@ module.exports = {
       await triviaQuestion.save();
     }
 
-      const question = decode(triviaQuestion.question);
+    return triviaQuestion;
-      const correctAnswer = decode(triviaQuestion.correct_answer);
+  } catch (error) {
-      const incorrectAnswers = triviaQuestion.incorrect_answers.map(decode);
+    console.error("Error fetching or saving trivia question:", error);
-      let allAnswers = [...incorrectAnswers, correctAnswer];
+    throw new Error("Error fetching trivia question");
-
-      // Declare answerMap before any conditions
-      let answerMap = {};
-
-      // Handle True/False questions specifically
-      if (triviaQuestion.type === "boolean") {
-        // Always keep "True" as option 1 and "False" as option 2
-        answerMap = { 1: "True", 2: "False" };
-      } else {
-        // Shuffle answers for other types of questions
-        allAnswers = allAnswers.sort(() => Math.random() - 0.5);
-
-        // Assign the map without redeclaring
-        answerMap = allAnswers.reduce((map, answer, index) => {
-          map[index + 1] = answer;
-          return map;
-        }, {});
   }
+};
 
-      // Create an embed with the trivia question and numbered options
+const createTriviaEmbed = (
-      const triviaEmbed = new EmbedBuilder()
+  categoryName,
+  question,
+  answerMap,
+  guild,
+  timeLimit
+) => {
+  return new EmbedBuilder()
     .setColor("#0099ff")
     .setTitle(`${categoryName} Trivia Question`)
     .setDescription(question)
@@ -170,12 +90,19 @@ module.exports = {
       text: `${guild.name} | Answer within ${timeLimit / 1000} seconds`,
       iconURL: guild.iconURL(),
     });
+};
 
-      await interaction.reply({
+const handleAnswerCollection = async (
-        embeds: [triviaEmbed],
+  interaction,
-      });
+  triviaQuestion,
-
+  answerMap,
-      // Create a message collector specific to the user
+  correctAnswer,
+  allAnswers,
+  timeLimit,
+  userId,
+  username
+) => {
+  try {
     const answerFilter = (response) => {
       const userInput = response.content.trim();
       const userAnswerNumber = parseInt(userInput, 10);
@@ -184,7 +111,6 @@ module.exports = {
         (answerMap[userAnswerNumber] &&
           answerMap[userAnswerNumber] === correctAnswer);
 
-        // Check if the input is a number within valid range or a text that matches one of the options
       return (
         response.author.id === userId &&
         (userAnswerText || (userAnswerNumber >= 1 && userAnswerNumber <= 4))
@@ -198,17 +124,16 @@ module.exports = {
     });
 
     answerCollector.on("collect", async (message) => {
+      try {
         const userInput = message.content.trim();
         const userAnswerNumber = parseInt(userInput, 10);
         const userAnswer = answerMap[userAnswerNumber] || userInput;
 
-        let resultMessage = "Incorrect! Better luck next time.";
+        let resultMessage =
+          userAnswer === correctAnswer
+            ? "Correct!"
+            : "Incorrect! Better luck next time.";
 
-        if (userAnswer === correctAnswer) {
-          resultMessage = "Correct!";
-        }
-
-        // Update leaderboard
         let userScore = await Leaderboard.findOne({ userId });
         if (!userScore) {
           userScore = new Leaderboard({
@@ -229,8 +154,15 @@ module.exports = {
           `${resultMessage} <@${userId}> You've answered ${userScore.correctAnswers} questions correctly out of ${userScore.gamesPlayed} games.`
         );
 
-        // Remove user from the ongoing trivia set once the game is finished
         ongoingTrivia.delete(userId);
+      } catch (error) {
+        console.error("Error processing collected answer:", error);
+        await interaction.followUp({
+          content: "There was an error processing your answer.",
+          ephemeral: true,
+        });
+        ongoingTrivia.delete(userId);
+      }
     });
 
     answerCollector.on("end", (collected, reason) => {
@@ -238,22 +170,106 @@ module.exports = {
         interaction.followUp(
           `<@${userId}> Time's up! You didn't answer in time.`
         );
-
-          // Remove user from the ongoing trivia set when the game times out
         ongoingTrivia.delete(userId);
       }
     });
   } catch (error) {
-      console.error("Error fetching trivia question:", error);
+    console.error("Error handling answer collection:", error);
+    await interaction.followUp({
+      content: "There was an error handling your response.",
+      ephemeral: true,
+    });
+    ongoingTrivia.delete(userId);
+  }
+};
 
-      // Inform the user about the error and let them retry
+module.exports = {
+  data: new SlashCommandBuilder()
+    .setName("trivia")
+    .setDescription("Play a trivia game")
+    .addStringOption((option) =>
+      option
+        .setName("category")
+        .setDescription("Choose a trivia category")
+        .setRequired(true)
+        .addChoices(
+          ...Object.entries(CATEGORY_MAP).map(([value, name]) => ({
+            name,
+            value,
+          }))
+        )
+    ),
+
+  async execute(interaction, client) {
+    const userId = interaction.user.id;
+    const username = interaction.user.username;
+    const guild = interaction.guild;
+    const timeLimit = 30000; // Time limit for answering in milliseconds
+
+    if (ongoingTrivia.has(userId)) {
+      return interaction.reply({
+        content:
+          "You already have an ongoing trivia game. Please finish it before starting a new one.",
+        ephemeral: true,
+      });
+    }
+
+    ongoingTrivia.add(userId);
+
+    try {
+      const categoryId = interaction.options.getString("category");
+      const categoryName = CATEGORY_MAP[categoryId] || "Video Games";
+
+      const triviaQuestion = await fetchTriviaQuestion(
+        categoryId,
+        categoryName
+      );
+      if (!triviaQuestion) throw new Error("Failed to fetch trivia question");
+
+      const question = decode(triviaQuestion.question);
+      const correctAnswer = decode(triviaQuestion.correct_answer);
+      const incorrectAnswers = triviaQuestion.incorrect_answers.map(decode);
+      let allAnswers = [...incorrectAnswers, correctAnswer];
+
+      let answerMap = {};
+
+      if (triviaQuestion.type === "boolean") {
+        answerMap = { 1: "True", 2: "False" };
+      } else {
+        allAnswers = allAnswers.sort(() => Math.random() - 0.5);
+        answerMap = allAnswers.reduce((map, answer, index) => {
+          map[index + 1] = answer;
+          return map;
+        }, {});
+      }
+
+      const triviaEmbed = createTriviaEmbed(
+        categoryName,
+        question,
+        answerMap,
+        guild,
+        timeLimit
+      );
+
+      await interaction.reply({ embeds: [triviaEmbed] });
+
+      await handleAnswerCollection(
+        interaction,
+        triviaQuestion,
+        answerMap,
+        correctAnswer,
+        allAnswers,
+        timeLimit,
+        userId,
+        username
+      );
+    } catch (error) {
+      console.error("Error executing trivia command:", error);
       await interaction.reply({
         content:
           "Trivia API hit the rate limit. Please try again in 5 seconds.",
         ephemeral: true,
       });
-
-      // Remove the user from the ongoing trivia set in case of an error
       ongoingTrivia.delete(userId);
     }
   },