// 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 canvasDir = path.join(__dirname, "cache", "canvas");
const templatePath = path.join(canvasDir, "pairing.jpg");

module.exports = {
  config: {
    name: "pairv4",
    version: "1.0.1",
    author: "MrTomXxX",
    countDown: 5,
    role: 0,
    shortDescription: "Random pairing",
    longDescription: "Pair yourself with a random group member",
    category: "picture",
    guide: {
      en: "{pn}"
    },
    dependencies: {
      axios: "",
      "fs-extra": "",
      jimp: ""
    }
  },

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

      if (!fs.existsSync(templatePath)) {
        const response = await axios.get(
          "https://i.pinimg.com/736x/15/fa/9d/15fa9d71cdd07486bb6f728dae2fb264.jpg",
          {
            responseType: "arraybuffer",
            timeout: 30000
          }
        );

        await fs.writeFile(templatePath, response.data);
      }
    } catch (error) {
      console.error(
        "[pairv4] Template download error:",
        error.message
      );
    }
  },

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

    try {
      // Match rate
      const rates = [
        "21%",
        "67%",
        "19%",
        "37%",
        "17%",
        "96%",
        "52%",
        "62%",
        "76%",
        "83%",
        "100%",
        "99%",
        "0%",
        "48%"
      ];

      const matchRate =
        rates[Math.floor(Math.random() * rates.length)];

      // Sender information
      const senderInfo = await api.getUserInfo(senderID);

      const senderName =
        senderInfo[senderID]?.name || "Unknown";

      // Group information
      const threadInfo =
        await api.getThreadInfo(threadID);

      if (
        !threadInfo ||
        !Array.isArray(threadInfo.participantIDs)
      ) {
        return api.sendMessage(
          "❌ | Group information পাওয়া যায়নি।",
          threadID,
          messageID
        );
      }

      // Sender বাদ দিয়ে random member নেওয়া
      const members =
        threadInfo.participantIDs.filter(
          id => String(id) !== String(senderID)
        );

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

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

      // Random member information
      const userInfo =
        await api.getUserInfo(randomID);

      const randomName =
        userInfo[randomID]?.name || "Unknown";

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

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

      // Send result
      await api.sendMessage(
        {
          body:
            `Congrats ${senderName} has been paired with ${randomName}\n` +
            `The Match rate is: ${matchRate}`,

          mentions: mentions,

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

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

    } catch (error) {
      console.error(
        "[pairv4] Command error:",
        error
      );

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


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

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

  const pairingImage =
    await Jimp.read(templatePath);

  const timestamp = Date.now();

  const outputPath = path.join(
    canvasDir,
    `pairing_${one}_${two}_${timestamp}.png`
  );

  const avatarOne = path.join(
    canvasDir,
    `avt_${one}_${timestamp}.png`
  );

  const avatarTwo = path.join(
    canvasDir,
    `avt_${two}_${timestamp}.png`
  );

  const accessToken =
    "6628568379%7Cc1e620fa708a1d5696fb991c1bde5662";

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

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

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

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

    // Circular avatars
    const circleOne =
      await makeCircle(avatarOne);

    const circleTwo =
      await makeCircle(avatarTwo);

    // Original positions maintained
    circleOne.resize(85, 85);
    circleTwo.resize(75, 75);

    pairingImage.composite(
      circleOne,
      355,
      100
    );

    pairingImage.composite(
      circleTwo,
      250,
      140
    );

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

    return outputPath;

  } finally {
    await fs.remove(avatarOne).catch(() => {});
    await fs.remove(avatarTwo).catch(() => {});
  }
}


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

  image.circle();

  return image;
}