// code from goatstore
// api: https://store.agi.bd
module.exports = {
  config: {
    name: "listbox",
    version: "1.3.1",
    author: "RS RIFAT",
    role: 2,
    countDown: 10,
    shortDescription: {
      en: "List all groups bot is in and make bot leave",
    },
    longDescription: {
      en: "Shows all group names where the bot is present. Reply with a group number to force the bot to leave that group.",
    },
    category: "system",
    guide: {
      en: "{pn} -> Reply with group number to make bot leave",
    },
  },

  onReply: async function ({ api, event, Reply }) {
    const { author, groupThreads } = Reply;
    const { senderID, threadID, messageID, body } = event;

    if (senderID !== author) {
      return api.sendMessage("⚠️ 𝗢𝗻𝗹𝘆 𝘁𝗵𝗲 𝗰𝗼𝗺𝗺𝗮𝗻𝗱 𝘂𝘀𝗲𝗿 𝗰𝗮𝗻 𝗿𝗲𝗽𝗹𝘆!", threadID, messageID);
    }

    const choice = parseInt(body);
    if (isNaN(choice) || choice < 1 || choice > groupThreads.length) {
      return api.sendMessage(
        `❌ 𝗜𝗻𝘃𝗮𝗹𝗶𝗱 𝗰𝗵𝗼𝗶𝗰𝗲!\n Please enter a number between 1 and ${groupThreads.length}.`,
        threadID,
        messageID
      );
    }

    const selectedGroup = groupThreads[choice - 1];
    const botID = api.getCurrentUserID();

    try {
      // 1. Send stylish notice to target group before leaving
      const leaveNoticeMsg = 
        `╭━━━〔 ⚠️ 𝗕𝗢𝗧 𝗟𝗘𝗔𝗩𝗜𝗡𝗚 ⚠️️ 〕━━━╮\n` +
        `│ \n` +
        `│  📢 𝗔𝘁𝘁𝗲𝗻𝘁𝗶𝗼𝗻 𝗘𝘃𝗲𝗿𝘆𝗼𝗻𝗲!\n` +
        `│  🤖 𝗧𝗵𝗶𝘀 𝗯𝗼𝘁 𝗶𝘀 𝗹𝗲𝗮𝘃𝗶𝗻𝗴 𝘁𝗵𝗶𝘀 𝗴𝗿𝗼𝘂𝗽\n` +
        `│  👑 𝗔𝗰𝘁𝗶𝗼𝗻 𝗜𝘀𝘀𝘂𝗲𝗱 𝗕𝘆: Admin\n` +
        `│ \n` +
        `╰━━━━━━━━━━━━━━━━━━━━━━╯\n` +
        `   👋 𝗚𝗼𝗼𝗱𝗯𝘆𝗲 &  Take Care! ❤️️`;

      try {
        await api.sendMessage(leaveNoticeMsg, selectedGroup.threadID);
      } catch (e) {
        // Continue even if sending message to target group fails
      }

      // 2. Make the bot leave the group
      await api.removeUserFromGroup(botID, selectedGroup.threadID);

      // 3. Stylish response to the admin
      const successMsg = 
        `╭━━━〔 🚪 𝗟𝗘𝗔𝗩𝗘 𝗦𝗨𝗖𝗖𝗘𝗦𝗦 〕━━━╮\n` +
        `│ \n` +
        `│  ✅ 𝗦𝘂𝗰𝗰𝗲𝘀𝘀𝗳𝘂𝗹𝗹𝘆 𝗟𝗲𝗳𝘁 𝗚𝗿𝗼𝘂𝗽!\n` +
        `│ \n` +
        `│  📌 𝗡𝗮𝗺𝗲: ${selectedGroup.name}\n` +
        `│  🆔 𝗧𝗵𝗿𝗲𝗮𝗱 𝗜𝗗: ${selectedGroup.threadID}\n` +
        `│ \n` +
        `╰━━━━━━━━━━━━━━━━━━━━━━╯`;

      return api.sendMessage(successMsg, threadID, messageID);

    } catch (error) {
      const errorMsg = 
        `╭━━━〔 ❌ 𝗟𝗘𝗔𝗩𝗘 𝗙𝗔𝗜𝗟𝗘𝗗 〕━━━╮\n` +
        `│ \n` +
        `│  ⚠️ Couldn't leave group!\n` +
        `│  📌 Group: ${selectedGroup.name}\n` +
        `│  📝 Reason: ${error.message || error}\n` +
        `│ \n` +
        `╰━━━━━━━━━━━━━━━━━━━━━━╯`;

      return api.sendMessage(errorMsg, threadID, messageID);
    }
  },

  onStart: async function ({ api, event, commandName, threadsData }) {
    const botID = api.getCurrentUserID();
    try {
      let dbThreads = [];
      if (threadsData && typeof threadsData.getAll === "function") {
        try {
          dbThreads = await threadsData.getAll();
        } catch (e) {
          console.error(e);
        }
      }
      if (!dbThreads.length && global.db && Array.isArray(global.db.allThreadData)) {
        dbThreads = global.db.allThreadData;
      }

      const dbGroupMap = new Map();
      if (Array.isArray(dbThreads)) {
        for (const t of dbThreads) {
          if (t && t.isGroup && !t.threadID?.includes("@msgr")) {
            const isBotInGroup = Array.isArray(t.members)
              ? t.members.some(m => m.userID == botID && m.inGroup !== false)
              : true;
            if (isBotInGroup) {
              dbGroupMap.set(String(t.threadID), t);
            }
          }
        }
      }

      let liveThreads = [];
      if (api && typeof api.getThreadList === "function") {
        try {
          const fetched = await api.getThreadList(100, null, ["INBOX"]);
          if (Array.isArray(fetched)) {
            liveThreads = fetched.filter(t => t && t.isGroup && !t.threadID?.includes("@msgr"));
          }
        } catch (e) {
          console.error(e);
        }
      }

      let groupThreads = [];
      if (liveThreads.length > 0) {
        groupThreads = liveThreads.map(t => {
          const tid = String(t.threadID);
          const dbData = dbGroupMap.get(tid);
          return {
            threadID: tid,
            name: t.threadName || t.name || dbData?.threadName || dbData?.name || "Unnamed Group"
          };
        });
      } else {
        groupThreads = Array.from(dbGroupMap.values()).map(t => ({
          threadID: String(t.threadID),
          name: t.threadName || t.name || "Unnamed Group"
        }));
      }

      if (groupThreads.length === 0) {
        return api.sendMessage("❌ No groups found.", event.threadID, event.messageID);
      }

      let msg = `🎯 𝗧𝗼𝘁𝗮𝗹 𝗚𝗿𝗼𝘂𝗽𝘀: ${groupThreads.length}\n━━━━━━━━━━━━━━\n`;

      groupThreads.forEach((group, index) => {
        msg += `📦 𝗚𝗿𝗼𝘂𝗽 ${index + 1}:\n`;
        msg += `📌 𝗡𝗮𝗺𝗲: ${group.name}\n`;
        msg += `🆔 𝗧𝗵𝗿𝗲𝗮𝗱 𝗜𝗗: ${group.threadID}\n`;
        msg += `━━━━━━━━━━━━━━\n`;
      });

      msg += `\n👉 Reply to this message with the group number to make the bot LEAVE that group! (Example: 1)`;

      return api.sendMessage(msg, event.threadID, (err, info) => {
        if (err) return console.error(err);

        if (global.GoatBot && global.GoatBot.onReply) {
          global.GoatBot.onReply.set(info.messageID, {
            commandName,
            author: event.senderID,
            groupThreads
          });
        } else if (global.client && global.client.handleReply) {
          global.client.handleReply.push({
            name: commandName,
            messageID: info.messageID,
            author: event.senderID,
            groupThreads
          });
        }
      }, event.messageID);

    } catch (error) {
      return api.sendMessage(
        `⚠️ Error while fetching group list:\n${error.message}`,
        event.threadID,
        event.messageID
      );
    }
  },
};