// code from goatstore
// api: https://store.agi.bd
const axios = require("axios");
const fs = require("fs-extra");
const path = require("path");
const Jimp = require("jimp");

const CANVAS_DIR = path.join(__dirname, "cache", "canvas");
const TEMPLATE_PATH = path.join(CANVAS_DIR, "pairing.png");

module.exports = {
  config: {
    name: "pairv3",
    version: "1.0.1",
    author: "MrTomXxX",
    countDown: 5,
    role: 0,
    shortDescription: "Randomly pair two group members",
    longDescription: "Creates a pairing image with the sender and a random group member",
    category: "picture",
    guide: {
      en: "{pn}"
    },
    dependencies: {
      axios: "",
      "fs-extra": "",
      jimp: ""
    }
  },

  onLoad: async function () {
    try {
      await fs.ensureDir(CANVAS_DIR);

      if (!fs.existsSync(TEMPLATE_PATH)) {
        const response = await axios.get(
          "https://i.postimg.cc/X7R3CLmb/267378493-3075346446127866-4722502659615516429-n.png",
          {
            responseType: "arraybuffer",
            timeout: 30000
          }
        );

        await fs.writeFile(TEMPLATE_PATH, response.data);
      }
    } catch (error) {
      console.error(
        "[pairv3] Failed to download template:",
        error.message
      );
    }
  },

  onStart: async function ({ api, event }) {
    const { threadID, messageID, senderID } = event;

    try {
      // Random pairing percentage
      const percentages = [
        "21%",
        "67%",
        "19%",
        "37%",
        "17%",
        "96%",
        "52%",
        "62%",
        "76%",
        "83%",
        "100%",
        "99%",
        "0%",
        "48%"
      ];

      const percentage =
        percentages[Math.floor(Math.random() * percentages.length)];

      // Get sender info
      const senderInfo = await api.getUserInfo(senderID);
      const senderName =
        senderInfo[senderID]?.name || "Unknown";

      // Get group info
      const threadInfo = await api.getThreadInfo(threadID);

      if (
        !threadInfo ||
        !threadInfo.participantIDs ||
        threadInfo.participantIDs.length < 2
      ) {
        return api.sendMessage(
          "❌ | গ্রুপে pairing করার মতো পর্যাপ্ত সদস্য নেই।",
          threadID,
          messageID
        );
      }

      // Random member
      const members = threadInfo.participantIDs.filter(
        id => String(id) !== String(senderID)
      );

      if (members.length === 0) {
        return api.sendMessage(
          "❌ | অন্য কোনো সদস্য পাওয়া যায়নি।",
          threadID,
          messageID
        );
      }

      const randomID =
        members[Math.floor(Math.random() * members.length)];

      // Get random member info
      const userInfo = await api.getUserInfo(randomID);
      const randomName =
        userInfo[randomID]?.name || "Unknown";

      // Create pairing image
      const imagePath = await makeImage({
        one: senderID,
        two: randomID
      });

      const mentions = [
        {
          id: senderID,
          tag: senderName
        },
        {
          id: randomID,
          tag: randomName
        }
      ];

      await api.sendMessage(
        {
          body:
            `Congratulations ${senderName} is paired with ${randomName}\n` +
            `💞 The odds are: 〘${percentage}〙`,

          mentions,

          attachment: fs.createReadStream(imagePath)
        },
        threadID,
        messageID
      );

      // Remove generated image
      setTimeout(() => {
        fs.remove(imagePath).catch(() => {});
      }, 3000);

    } catch (error) {
      console.error("[pairv3] Error:", error);

      return api.sendMessage(
        `❌ | Pairing failed!\n\n${error.message}`,
        threadID,
        messageID
      );
    }
  }
};


// ==============================
// Create Pairing Image
// ==============================
async function makeImage({ one, two }) {
  await fs.ensureDir(CANVAS_DIR);

  if (!fs.existsSync(TEMPLATE_PATH)) {
    throw new Error("pairing.png template not found");
  }

  const pairingImage = await Jimp.read(TEMPLATE_PATH);

  const outputPath = path.join(
    CANVAS_DIR,
    `pairing_${one}_${two}_${Date.now()}.png`
  );

  const avatarOne = path.join(
    CANVAS_DIR,
    `avt_${one}_${Date.now()}.png`
  );

  const avatarTwo = path.join(
    CANVAS_DIR,
    `avt_${two}_${Date.now()}.png`
  );

  try {
    // Download first avatar
    const avatarResponseOne = await axios.get(
      `https://graph.facebook.com/${one}/picture?width=512&height=512&access_token=6628568379%7Cc1e620fa708a1d5696fb991c1bde5662`,
      {
        responseType: "arraybuffer",
        timeout: 30000
      }
    );

    await fs.writeFile(
      avatarOne,
      Buffer.from(avatarResponseOne.data)
    );

    // Download second avatar
    const avatarResponseTwo = await axios.get(
      `https://graph.facebook.com/${two}/picture?width=512&height=512&access_token=6628568379%7Cc1e620fa708a1d5696fb991c1bde5662`,
      {
        responseType: "arraybuffer",
        timeout: 30000
      }
    );

    await fs.writeFile(
      avatarTwo,
      Buffer.from(avatarResponseTwo.data)
    );

    // Make circular avatars
    const circleOne = await makeCircle(avatarOne);
    const circleTwo = await makeCircle(avatarTwo);

    // Resize and place avatars
    circleOne.resize(150, 150);
    circleTwo.resize(150, 150);

    pairingImage.composite(
      circleOne,
      980,
      200
    );

    pairingImage.composite(
      circleTwo,
      140,
      200
    );

    // Save image
    await pairingImage.writeAsync(outputPath);

    return outputPath;

  } finally {
    // Delete temporary avatars
    await fs.remove(avatarOne).catch(() => {});
    await fs.remove(avatarTwo).catch(() => {});
  }
}


// ==============================
// Circular Avatar
// ==============================
async function makeCircle(imagePath) {
  const image = await Jimp.read(imagePath);

  image.circle();

  return image;
}