index.js

// Import necessary modules
const express = require('express');
const { sinhalaSub } = require("mrnima-moviedl");

const FormData = require('form-data');

const { catbox } = require('./catbox'); // Import the Catbox uploader


const { exec } = require("child_process");

const yts = require("yt-search")


// Initialize Express app for HTTP server
const app = express();
const PORT = process.env.PORT || 3000;



// Start the HTTP server
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});


//
const TelegramBot = 
require('node-telegram-bot-api');
const axios = require('axios');
const fs = require('fs');
const apiKey = '7398508893:AAFqoZK_n0FNZ5I9_5L4BpyDSh3YvatZ3B8'; 
// Replace 'YOUR_TELEGRAM_BOT_TOKEN' with your bot token
const bot = new TelegramBot('7398508893:AAFE6xOytstrMZ0PpRa3ieH6SLBy9TR9vq4', { polling: true });

// Set up a list for tracking muted users
const mutedUsers = new Set();

// Anti-link feature variable
let antiLinkActive = false;

// Check if user is admin
const isAdmin = async (chatId, userId) => {
    try {
        const member = await bot.getChatMember(chatId, userId);
        return member.status === 'administrator' || member.status === 'creator';
    } catch (error) {
        return false;
    }
};





// /tiktok command
bot.onText(/\/(tiktok|tt|ttmedia)(?: (.+))?/, async (msg, match) => {
    const chatId = msg.chat.id;
    const text = match[2]; // Extract the TikTok link from the command

    if (!text) {
        // If no TikTok link is provided, send a usage guide
        return bot.sendMessage(chatId, "❌ Please provide a TikTok link.\nExample: `/tiktok https://www.tiktok.com/@username/video/1234567890`");
    }

    bot.sendMessage(chatId, "🔄 Fetching your TikTok media... Please wait.");

    try {
        // Fetch TikTok media using the external API
        const response = await axios.get(`https://api.paxsenix.biz.id/dl/tiktok?url=${encodeURIComponent(text)}`);
        const data = response.data;

        if (data && data.downloadsUrl) {
            // Send the video
            await bot.sendVideo(chatId, data.downloadsUrl.video);

            // Send the audio
            await bot.sendAudio(chatId, data.downloadsUrl.music);
        } else {
            bot.sendMessage(chatId, "❌ Unable to fetch TikTok media. Please check the link and try again.");
        }
    } catch (error) {
        console.error("Error during TikTok download command:");
        bot.sendMessage(chatId, "❌ An error occurred while processing your request. Please try again later.");
    }
});


bot.onText(/\/couplepp/, async (msg) => {
    const chatId = msg.chat.id;

    try {
        // Inform the user that the bot is fetching the pictures
        await bot.sendMessage(chatId, "🔍 *Fetching couple profile pictures...*", { parse_mode: "Markdown" });

        // Fetch the data from the API
        const apiUrl = "https://api.maskser.me/api/randomgambar/couplepp";
        const response = await axios.get(apiUrl);

        if (response.data.status) {
            const { male, female } = response.data.result;

            // Send the male picture
            await bot.sendPhoto(chatId, male, {
                caption: "👦 *Male Picture*",
                parse_mode: "Markdown"
            });

            // Send the female picture
            await bot.sendPhoto(chatId, female, {
                caption: "👧 *Female Picture*",
                parse_mode: "Markdown"
            });
        } else {
            bot.sendMessage(chatId, "❌ Failed to fetch couple pictures. Please try again later.");
        }
    } catch (error) {
        console.error("Error fetching couple pictures:");
        bot.sendMessage(chatId, "❌ An error occurred while fetching couple pictures. Please try again.");
    }
});


// Handle /gpt command
bot.onText(/\/gpt (.+)/, async (msg, match) => {
  const chatId = msg.chat.id;
  const query = match[1]?.trim();

  if (!query) {
    return bot.sendMessage(chatId, "❌ Please provide a prompt after the /gpt command.\nExample: `/gpt What is AI?`", {
      parse_mode: "Markdown",
    });
  }

  try {
    // Show typing indicator
    await bot.sendChatAction(chatId, "typing");

    // Make a request to the new GPT API
    const apiUrl = `https://api.paxsenix.biz.id/ai/gpt4?text=${encodeURIComponent(query)}`;
    const { data } = await axios.get(apiUrl);

    

    // Check the API response
    if (!data.ok || !data.message) {
      return bot.sendMessage(chatId, `❌ GPT API Error: Unable to fetch a response. Please try again later.`);
    }

    // Send the GPT response to the user
    await bot.sendMessage(chatId, `${data.message}`, { parse_mode: "Markdown" });
  } catch (error) {
    console.error("Error fetching GPT response:");
    await bot.sendMessage(chatId, "❌ An error occurred while fetching the GPT response. Please try again later.");
  }
});


bot.onText(/\/url/, async (msg) => {
    const chatId = msg.chat.id;

    // Check if the message is a reply to an image or video
    const fileId = msg.reply_to_message?.photo?.[msg.reply_to_message.photo.length - 1]?.file_id ||
                   msg.reply_to_message?.video?.file_id;

    if (!fileId) {
        return bot.sendMessage(chatId, "❗ *Reply to an image or video with /url to get a public link.*", { parse_mode: "Markdown" });
    }

    try {
        // React to indicate processing
        const processingMsg = await bot.sendMessage(chatId, "⏳ *Uploading your file...*", { parse_mode: "Markdown" });

        // Download the file locally
        const filePath = await bot.downloadFile(fileId, "./downloads");

        // Upload the file to Catbox
        const uploadResponse = await catbox(filePath);

        // Check and send the result
        if (uploadResponse.url) {
            await bot.sendMessage(chatId, `✅ *Upload Successful!*\n\n🔗 *URL:*\n${uploadResponse.url}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`, { parse_mode: "Markdown" });
        } else {
            await bot.sendMessage(chatId, "❌ *Upload Failed. Please try again.*", { parse_mode: "Markdown" });
        }

        // Clean up the downloaded file
        fs.unlinkSync(filePath);
        await bot.deleteMessage(chatId, processingMsg.message_id);
    } catch (error) {
        console.error("Error in /url command:");
        bot.sendMessage(chatId, `❌ *An error occurred`, { parse_mode: "Markdown" });
    }
});



bot.onText(/\/remini/, async (msg) => {
    const chatId = msg.chat.id;

    // Check if the message is a reply to an image
    const fileId = msg.reply_to_message?.photo?.[msg.reply_to_message.photo.length - 1]?.file_id;

    if (!fileId) {
        return bot.sendMessage(chatId, "❗ *Reply to an image with /remini to enhance it.*", { parse_mode: "Markdown" });
    }

    try {
        // React to indicate processing
        const processingMsg = await bot.sendMessage(chatId, "⏳ *Enhancing your image...*", { parse_mode: "Markdown" });

        // Download the image locally
        const filePath = await bot.downloadFile(fileId, "./downloads");

        // Upload the image to Catbox
        const uploadResponse = await catbox(filePath);

        if (!uploadResponse.url) {
            fs.unlinkSync(filePath); // Clean up the downloaded file
            return bot.sendMessage(chatId, "❌ *Upload Failed. Please try again.*", { parse_mode: "Markdown" });
        }

        const imageUrl = uploadResponse.url; // Get the uploaded image URL

        // Call the Remini API with the uploaded image URL
        const enhancedImageUrl = `https://bk9.fun/tools/enhance?url=${encodeURIComponent(imageUrl)}`;

        // Send the enhanced image back to the user
        await bot.sendPhoto(chatId, enhancedImageUrl, {
            caption: `✅ *Successfully Enhanced Your Image!*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
            parse_mode: "Markdown",
        });

        // Clean up the downloaded file
        fs.unlinkSync(filePath);
        await bot.deleteMessage(chatId, processingMsg.message_id);
    } catch (error) {
        console.error("Error in /remini command:");
        bot.sendMessage(chatId, `❌ *An error occurred`, { parse_mode: "Markdown" });
    }
});





// /video command
bot.onText(/\/video (.+)/, async (msg, match) => {
    const chatId = msg.chat.id;
    const query = match[1]?.trim();

    if (!query) {
        return bot.sendMessage(chatId, "❗ *Usage*: `/video <search term>`", { parse_mode: 'Markdown' });
    }

    try {
        const searchMsg = await bot.sendMessage(chatId, "🔍 *Searching for your video...*", { parse_mode: "Markdown" });

        const search = await yts(query);
        const video = search.all[0];
        if (!video) {
            return bot.sendMessage(chatId, "❌ Video not found!");
        }

        const apiUrl = `https://apis.davidcyriltech.my.id/download/ytmp4`;
        const response = await axios.get(apiUrl, { params: { url: video.url } });
        const { success, result } = response.data;

        if (success && result) {
            const { title, download_url } = result;

            await bot.sendVideo(chatId, download_url, {
                caption: `🎬 *Here is your video:*\n🎥 *${title}*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
                parse_mode: "Markdown"
            });
        } else {
            bot.sendMessage(chatId, "❌ Failed to fetch the video. Please try again.");
        }

        await bot.deleteMessage(chatId, searchMsg.message_id);
    } catch (err) {
        console.error("Error in /video command:", err);
        bot.sendMessage(chatId, "❌ An error occurred while processing your request.");
    }
});

// /ytmp4 command
bot.onText(/\/ytmp4 (.+)/, async (msg, match) => {
    const chatId = msg.chat.id;
    const youtubeLink = match[1]?.trim();

    if (!youtubeLink) {
        return bot.sendMessage(chatId, "❗ *Usage*: `/ytmp4 <YouTube link>`\nExample: `/ytmp4 https://youtube.com/watch?v=iI34LYmJ1Fs`", { parse_mode: 'Markdown' });
    }

    try {
        const loadingMsg = await bot.sendMessage(chatId, "🔍 *Processing your video...*", { parse_mode: "Markdown" });

        const apiUrl = `https://apis.davidcyriltech.my.id/download/ytmp4`;
        const response = await axios.get(apiUrl, { params: { url: youtubeLink } });
        const { success, result } = response.data;

        if (success && result) {
            const { title, download_url } = result;

            await bot.sendVideo(chatId, download_url, {
                caption: `🎬 *${title}*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
                parse_mode: "Markdown"
            });
        } else {
            bot.sendMessage(chatId, "❌ Failed to fetch the video. Please check the link and try again.");
        }

        await bot.deleteMessage(chatId, loadingMsg.message_id);
    } catch (err) {
        console.error("Error in /ytmp4 command:", err);
        bot.sendMessage(chatId, "❌ An error occurred while processing your request.");
    }
});

// /ytmp3 command
bot.onText(/\/ytmp3 (.+)/, async (msg, match) => {
    const chatId = msg.chat.id;
    const youtubeLink = match[1]?.trim();

    if (!youtubeLink) {
        return bot.sendMessage(chatId, "❗ *Usage*: `/ytmp3 <YouTube link>`\nExample: `/ytmp3 https://youtube.com/watch?v=iI34LYmJ1Fs`", { parse_mode: 'Markdown' });
    }

    try {
        const loadingMsg = await bot.sendMessage(chatId, "🔍 *Processing your audio...*", { parse_mode: "Markdown" });

        const apiUrl = `https://apis.davidcyriltech.my.id/download/ytmp3`;
        const response = await axios.get(apiUrl, { params: { url: youtubeLink } });
        const { success, result } = response.data;

        if (success && result) {
            const { title, download_url } = result;

            await bot.sendAudio(chatId, download_url, {
                caption: `🎧 *${title}*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
                parse_mode: "Markdown"
            });
        } else {
            bot.sendMessage(chatId, "❌ Failed to fetch the audio. Please check the link and try again.");
        }

        await bot.deleteMessage(chatId, loadingMsg.message_id);
    } catch (err) {
        console.error("Error in /ytmp3 command:", err);
        bot.sendMessage(chatId, "❌ An error occurred while processing your request.");
    }
});




// /play command
bot.onText(/\/play(?: (.+))?/, async (msg, match) => {
    const chatId = msg.chat.id;
    const inputText = match[1];

    if (!inputText) {
        return bot.sendMessage(chatId, "❌ Please provide the song name.\nExample: `/play Faded by Alan Walker`", { parse_mode: "Markdown" });
    }

    try {
        await bot.sendMessage(chatId, "🔍 Searching for your song...");

        const search = await yts(inputText);
        const video = search.all[0];

        if (!video) {
            return bot.sendMessage(chatId, "❌ Sorry, I couldn't find the song. Try another keyword.");
        }

        const apiUrl = `https://apis.davidcyriltech.my.id/download/ytmp3?url=${encodeURIComponent(video.url)}`;
        const response = await axios.get(apiUrl);
        const { success, result } = response.data;

        if (success && result) {
            const { title, thumbnail, download_url } = result;

            await bot.sendPhoto(chatId, thumbnail, {
                caption: `🎶 *Music Player* 🎶\n\n` +
                         `🎵 *Title:* ${title}\n` +
                         `🔗 [Watch on YouTube](${video.url})\n\n` +
                         `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
                parse_mode: "Markdown",
            });

            await bot.sendAudio(chatId, download_url, {
                caption: `🎧 *Here's your song:*\n🎵 *Title:* ${title}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
                parse_mode: "Markdown",
            });
        } else {
            bot.sendMessage(chatId, "❌ Unable to download the song. Please try again later.");
        }
    } catch (error) {
        console.error("Error during /play command:", error);
        bot.sendMessage(chatId, "❌ An error occurred while processing your request. Please try again later.");
    }
});


                

let chatbotActive = {}; // Stores active chatbot users
let conversationIds = {}; // Stores conversation ID for each user

bot.onText(/\/gitclone (.+)/, async (msg, match) => {
    const chatId = msg.chat.id;
    const repoUrl = match[1]?.trim();

    if (!repoUrl) {
        return bot.sendMessage(chatId, "❗ *Usage*: `/gitclone <GitHub Repo URL>`\nExample: `/gitclone https://github.com/DeeCeeXxx2/Queen_Anita-V3`", { parse_mode: 'Markdown' });
    }

    if (!repoUrl.includes("github.com")) {
        return bot.sendMessage(chatId, "❌ *Invalid GitHub link! Please provide a valid URL.*");
    }

    try {
        let regex = /(?:https|git)(?::\/\/|@)github\.com[\/:]([^\/:]+)\/(.+)/i;
        let [, user, repo] = repoUrl.match(regex) || [];
        repo = repo.replace(/.git$/, "");
        let zipUrl = `https://api.github.com/repos/${user}/${repo}/zipball`;

        // Fetch file name from GitHub API
        let response = await fetch(zipUrl, { method: "HEAD" });
        let filename = response.headers.get("content-disposition").match(/attachment; filename=(.*)/)[1];

        await bot.sendDocument(chatId, zipUrl, {
            caption: `📦 *Repository:* ${repo}\n🔗 *Download Link:* [Click Here](${zipUrl})\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
            parse_mode: "Markdown",
            fileName: filename + ".zip",
            mimetype: "application/zip"
        });
    } catch (err) {
        console.error("Error in /gitclone command:", err);
        bot.sendMessage(chatId, "❌ *An error occurred while fetching the repository. Please try again later.*");
    }
});

bot.onText(/\/chatbot$/, async (msg) => {
    const chatId = msg.chat.id;

    await bot.sendMessage(
        chatId,
        "❗ *Invalid Command!*\n\nUse:\n✅ `/chatbot on` - To activate AI chat\n❌ `/chatbot off` - To deactivate AI chat",
        { parse_mode: "Markdown" }
    );
});






bot.onText(/\/mediafire (.+)/, async (msg, match) => {
    const chatId = msg.chat.id;
    const mediafireUrl = match[1]?.trim();

    if (!mediafireUrl) {
        return bot.sendMessage(chatId, "❗ *Usage*: `/mediafire <MediaFire Link>`\nExample: `/mediafire https://www.mediafire.com/file/n6tgcrktbnov1oy/Queen_Anita-V4.zip/file`", { parse_mode: 'Markdown' });
    }

    try {
        const loadingMsg = await bot.sendMessage(chatId, "📥 *Fetching file details...*", { parse_mode: "Markdown" });

        const apiUrl = `https://apis.davidcyriltech.my.id/mediafire?url=${encodeURIComponent(mediafireUrl)}`;
        const response = await axios.get(apiUrl);
        const { success, result } = response.data;

        if (success && result) {
            const { fileName, downloadLink } = result;
            const filePath = path.join(__dirname, "temp", fileName.replace(/[^\w\s]/gi, "_"));

            // Step 1: Download the file locally
            const writer = fs.createWriteStream(filePath);
            const fileResponse = await axios({
                url: downloadLink,
                method: "GET",
                responseType: "stream",
            });

            fileResponse.data.pipe(writer);

            await new Promise((resolve, reject) => {
                writer.on("finish", resolve);
                writer.on("error", reject);
            });

            // Step 2: Send the file
            await bot.sendDocument(chatId, filePath, {
                caption: `📦 *File Name:* ${fileName}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
                parse_mode: "Markdown",
            });

            // Step 3: Delete the file after sending
            fs.unlinkSync(filePath);
        } else {
            bot.sendMessage(chatId, "❌ *Failed to fetch file details! Please check the MediaFire URL and try again.*");
        }

        await bot.deleteMessage(chatId, loadingMsg.message_id);
    } catch (error) {
        console.error("Error in /mediafire command:", error);
        bot.sendMessage(chatId, "❌ *An error occurred while processing your request. Please try again later.*");
    }
});

bot.onText(/\/ss (.+)/, async (msg, match) => {
    const chatId = msg.chat.id;
    const websiteUrl = match[1]?.trim();

    if (!websiteUrl) {
        return bot.sendMessage(chatId, "❗ *Usage*: `/ssweb <Website URL>`\nExample: `/ssweb https://example.com`", { parse_mode: 'Markdown' });
    }

    try {
        const loadingMsg = await bot.sendMessage(chatId, "📸 *Capturing screenshot...*", { parse_mode: "Markdown" });

        const apiUrl = `https://apis.davidcyriltech.my.id/ssweb?url=${encodeURIComponent(websiteUrl)}`;
        await bot.sendPhoto(chatId, apiUrl, {
            caption: `🖼️ *Screenshot of:* ${websiteUrl}`,
            parse_mode: "Markdown"
        });

        await bot.deleteMessage(chatId, loadingMsg.message_id);
    } catch (error) {
        console.error("Error in /ssweb command:", error);
        bot.sendMessage(chatId, "❌ *Failed to capture the screenshot. Please try again later.*");
    }
});






bot.onText(/\/bible (.+)/, async (msg, match) => {
    const chatId = msg.chat.id;
    const chapterInput = match[1]?.trim();

    if (!chapterInput) {
        return bot.sendMessage(
            chatId,
            "❗ *Usage*: `/bible <chapter and verse>`\nExample: `/bible john 3:16`",
            { parse_mode: "Markdown" }
        );
    }

    const BASE_URL = "https://bible-api.com";

    try {
        // Fetch the chapter data from the Bible API
        const response = await axios.get(`${BASE_URL}/${encodeURIComponent(chapterInput)}`);
        if (!response.data) {
            throw new Error("Failed to fetch the Bible chapter. Please check the input and try again.");
        }

        const chapterData = response.data;

        // Format the Bible chapter message
        const bibleChapter = `
📖 *The Holy Bible*\n
📜 *Chapter:* ${chapterData.reference}\n
📚 *Translation:* ${chapterData.translation_name}\n
📖 *Number of Verses:* ${chapterData.verses.length}\n
🔮 *Chapter Content:*\n${chapterData.text}
        `;

        // Send the formatted message with an image
        await bot.sendPhoto(chatId, "./atomic.jpg", {
            caption: bibleChapter,
            parse_mode: "Markdown",
        });
    } catch (error) {
        console.error("Error in /bible command:");
        bot.sendMessage(chatId, `❌ Error: `);
    }
});


bot.onText(/\/text2image (.+)/, async (msg, match) => {
    const chatId = msg.chat.id;
    const prompt = match[1]; // Extract the prompt from the command

    // Check if the user provided a prompt
    if (!prompt) {
        return bot.sendMessage(chatId, "❌ *Please provide a prompt!* \n\nUsage: `/magicstudio <prompt>`", { parse_mode: "Markdown" });
    }

    try {
        // Inform the user the process has started
        await bot.sendMessage(chatId, "✨ *Generating image... Please wait!*", { parse_mode: "Markdown" });

        // API URL to generate the image
        const apiUrl = `https://bk9.fun/ai/magicstudio?prompt=${encodeURIComponent(prompt)}`;

        // Fetch the generated image from the API
        const response = await axios.get(apiUrl, { responseType: "stream" });

        // Send the image back to the user
        await bot.sendPhoto(chatId, response.data, {
            caption: `🖼️ *Here's your generated image for:* \`${prompt}\`\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
            parse_mode: "Markdown"
        });

    } catch (error) {
        console.error("Error generating image:");
        bot.sendMessage(chatId, "❌ *Failed to generate the image. Please try again later!*", { parse_mode: "Markdown" });
    }
});
// /apk command
bot.onText(/\/apk (.+)/, async (msg, match) => {
  const chatId = msg.chat.id;
  const packageName = match[1]?.trim();

  if (!packageName) {
    return bot.sendMessage(chatId, "❗ *Usage*: `/apk <package_name>`\nExample: `/apk com.whatsapp`", { parse_mode: "Markdown" });
  }

  try {
    // Step 1: Fetch APK details from the API
    const apiUrl = `https://bk9.fun/download/apk?id=${encodeURIComponent(packageName)}`;
    const response = await axios.get(apiUrl);
    const { status, BK9 } = response.data;

    if (!status || !BK9) {
      return bot.sendMessage(chatId, "❌ APK details not found. Please check the package name and try again.");
    }

    // Step 2: Prepare APK details message
    const apkDetails = `📱 *APK Details*\n\n` +
      `*Name:* ${BK9.name}\n` +
      `*Last Updated:* ${BK9.lastup}\n` +
      `*Package:* \`${BK9.package}\`\n\n` +
      `\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`;

    const downloadLink = BK9.dllink;

    // Step 3: Create Inline Keyboard Button for download link
    const inlineKeyboard = [
      [
        {
          text: "📥 Download APK",
          url: downloadLink,
        },
      ],
    ];

    const options = {
      reply_markup: {
        inline_keyboard: inlineKeyboard,
      },
      parse_mode: "Markdown",
    };

    // Step 4: Send APK details with the download button
    await bot.sendPhoto(chatId, BK9.icon, {
      caption: apkDetails,
      ...options,
    });
  } catch (error) {
    console.error("Error fetching APK details:");
    await bot.sendMessage(chatId, "❌ An error occurred while fetching APK details. Please try again.");
  }
});


// /movie command
bot.onText(/\/movie (.+)/, async (msg, match) => {
  const chatId = msg.chat.id;
  const query = match[1]?.trim();

  if (!query) {
    return bot.sendMessage(chatId, "❌ *Please provide a search query!*\nExample: `/movie Deadpool`", { parse_mode: "Markdown" });
  }

  try {
    // Step 1: Search SinhalaSub for movies
    const sinhala = await sinhalaSub();
    const results = await sinhala.search(query);
    const movies = results.result.slice(0, 10); // Limit results to 10

    if (!movies.length) {
      return bot.sendMessage(chatId, `❌ No results found for: *${query}*`, { parse_mode: "Markdown" });
    }

    // Step 2: Create Inline Keyboard Buttons for movies
    const inlineKeyboard = movies.map((movie, index) => [
      {
        text: `${index + 1}. ${movie.title}`,
        callback_data: `movie_${index}`, // Unique identifier for each movie
      },
    ]);

    const options = {
      reply_markup: {
        inline_keyboard: inlineKeyboard,
      },
      parse_mode: "Markdown",
    };

    await bot.sendMessage(chatId, `📽️ *Search Results for:* \`${query}\`\n\nSelect a movie from the list:`, options);

    // Step 3: Handle movie selection
    bot.on("callback_query", async (callbackQuery) => {
      const { data, message } = callbackQuery;

      // Check if the callback is for this movie selection
      if (data.startsWith("movie_")) {
        const selectedIndex = parseInt(data.split("_")[1], 10);
        const selectedMovie = movies[selectedIndex];
        const apiUrl = `https://api-site-2.vercel.app/api/sinhalasub/movie?url=${encodeURIComponent(selectedMovie.link)}`;

        try {
          // Step 4: Fetch download links
          const { data: movieData } = await axios.get(apiUrl);
          const movieDetails = movieData.result;
          const downloadLinks = movieDetails.dl_links || [];

          if (!downloadLinks.length) {
            return bot.sendMessage(chatId, "❌ No PixelDrain links found for this movie.");
          }

          // Step 5: Create Inline Keyboard Buttons for direct download links
          const qualityKeyboard = downloadLinks.map((link) => {
            const pixelDrainId = link.link.split("/").pop(); // Extract the file ID
            const directDownloadLink = `https://pixeldrain.com/api/file/${pixelDrainId}?download`; // Use /download endpoint
            return [
              {
                text: `${link.quality} - ${link.size}`,
                url: directDownloadLink, // Direct download link
              },
            ];
          });

          const qualityOptions = {
            reply_markup: {
              inline_keyboard: qualityKeyboard,
            },
            parse_mode: "Markdown",
          };

          await bot.sendMessage(
            chatId,
            `🎥 *Available Qualities for:* \`${movieDetails.title}\`\n\nSelect a quality to download directly:\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
            qualityOptions
          );

          // Acknowledge the callback to avoid timeout errors
          bot.answerCallbackQuery(callbackQuery.id);
        } catch (error) {
          console.error("Error fetching movie details:");
          await bot.sendMessage(chatId, "❌ Failed to fetch movie details. Please try again.");
        }
      }
    });
  } catch (error) {
    console.error("Error executing /movie command:");
    await bot.sendMessage(chatId, "❌ An error occurred while processing your request.");
  }
});




bot.onText(/\/shazam/, async (msg) => {
    const chatId = msg.chat.id;

    // Ensure the command is a reply to an audio or video message
    const fileId = msg.reply_to_message?.audio?.file_id || msg.reply_to_message?.video?.file_id;
    if (!fileId) {
        return bot.sendMessage(chatId, "❌ Please reply to an audio or video file with /shazam to identify it.");
    }

    try {
        // Notify the user that the bot is processing the file
        const processingMsg = await bot.sendMessage(chatId, "🎵 Identifying the audio... Please wait!");

        // Download the file locally
        const filePath = await bot.downloadFile(fileId, "./downloads");

        // Upload the file to Catbox
        const uploadResponse = await catbox(filePath);
        if (!uploadResponse.url) {
            throw new Error("Failed to upload the file for analysis.");
        }

        // Call Shazam API
        const shazamApiUrl = `https://api.paxsenix.biz.id/tools/shazam?url=${encodeURIComponent(uploadResponse.url)}`;
        const shazamResponse = await axios.get(shazamApiUrl);
        const shazamResult = shazamResponse.data;

        // Handle Shazam API response
        if (shazamResult?.ok && shazamResult?.track) {
            const { title, artist, url } = shazamResult.track;
            const resultMessage = `🎶 *Audio Identified:*\n\n` +
                `🎵 *Title:* ${title}\n` +
                `🎤 *Artist:* ${artist}\n` +
                `[🔗 Listen on Shazam](${url})\n\n` +
                `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`;

            await bot.sendMessage(chatId, resultMessage, { parse_mode: "Markdown" });
        } else {
            bot.sendMessage(chatId, "❌ Unable to identify the audio. Please try again with a different file.");
        }

        // Cleanup local file
        fs.unlinkSync(filePath);
        await bot.deleteMessage(chatId, processingMsg.message_id);
    } catch (error) {
        console.error("Error in /shazam command:");
        bot.sendMessage(chatId, "⚠️ An error occurred while processing your request. Please try again later.");
    }
});


bot.onText(/\/(image|img)(?: (.+))?/, async (msg, match) => {
    const chatId = msg.chat.id;
    const query = match[2]; // Extract the search query from the command

    if (!query) {
        return bot.sendMessage(
            chatId,
            "❌ Please provide a search query.\n\n*Usage:* `/image <query>`\n*Example:* `/image cats`",
            { parse_mode: "Markdown" }
        );
    }

    bot.sendMessage(chatId, "🔍 Searching for images... Please wait.");

    try {
        // Call the Bing Image Search API
        const apiResponse = await axios.get(`https://api.siputzx.my.id/api/s/bimg`, {
            params: { query: query }
        });

        if (apiResponse.status === 200 && apiResponse.data.status) {
            const images = apiResponse.data.data;

            if (!images || images.length === 0) {
                return bot.sendMessage(chatId, `❌ No images found for "${query}". Please try another query.`);
            }

            // Limit to max 5 images
            const maxImages = Math.min(images.length, 5);
            for (let i = 0; i < maxImages; i++) {
                await bot.sendPhoto(chatId, images[i], {
                    caption: `🔎 *Image Search Result:*\n\n📄 *Query:* "${query}"\n📷 *Image ${i + 1}/${maxImages}*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
                    parse_mode: "Markdown"
                });
            }
        } else {
            bot.sendMessage(chatId, "❌ Failed to fetch images. Please try again later.");
        }
    } catch (error) {
        console.error("Error in /imagesearch command:");
        bot.sendMessage(
            chatId,
            `⚠️ An error occurred:\n\n*Message:*`,
            { parse_mode: "Markdown" }
        );
    }
});

bot.onText(/\/(spotifysearch)(?: (.+))?/, async (msg, match) => {
    const chatId = msg.chat.id;
    const query = match[2]; // Extract the search query from the command

    if (!query) {
        return bot.sendMessage(
            chatId,
            "❌ Please provide a search query.\n\n*Usage:* `/spotifysearch <query>`\n*Example:* `/spotifysearch Spectre`",
            { parse_mode: "Markdown" }
        );
    }

    bot.sendMessage(chatId, "🔍 Searching for tracks on Spotify... Please wait.");

    try {
        // Call the Spotify Search API
        const apiResponse = await axios.get(`https://api.giftedtech.my.id/api/search/spotifysearch`, {
            params: { apikey: "gifted-md", query: query }
        });

        if (apiResponse.status === 200 && apiResponse.data.success) {
            const tracks = apiResponse.data.results;

            if (!tracks || tracks.length === 0) {
                return bot.sendMessage(chatId, `❌ No tracks found for "${query}". Please try another query.`);
            }

            // Limit to max 5 tracks
            const maxTracks = Math.min(tracks.length, 5);
            let message = `🎧 *Spotify Search Results:*\n\n`;
            tracks.slice(0, maxTracks).forEach((track, index) => {
                message += `🎵 *${index + 1}. ${track.title}*\n` +
                           `👤 *Artist:* ${track.artist}\n` +
                           `⏱️ *Duration:* ${track.duration}\n` +
                           `🔗 [Listen on Spotify](${track.url})\n\n`;
            });

            bot.sendMessage(chatId, message, { parse_mode: "Markdown" });
        } else {
            bot.sendMessage(chatId, "❌ Failed to fetch tracks. Please try again later.");
        }
    } catch (error) {
        console.error("Error in /spotifysearch command:");
        bot.sendMessage(
            chatId,
            `⚠️ An error occurred:\n\n*Message:*`,
            { parse_mode: "Markdown" }
        );
    }
});


bot.onText(/\/(spotify-download|spotdl)(?: (.+))?/, async (msg, match) => {
    const chatId = msg.chat.id;
    const spotifyUrl = match[2]; // Extract the Spotify track URL from the command

    if (!spotifyUrl) {
        return bot.sendMessage(
            chatId,
            "❌ Please provide a Spotify track URL.\n\n*Usage:* `/spotify-download <Spotify URL>`\n*Example:* `/spotify-download https://open.spotify.com/track/2DGa7iaidT5s0qnINlwMjJ`",
            { parse_mode: "Markdown" }
        );
    }

    bot.sendMessage(chatId, "🔄 Fetching your Spotify track... Please wait.");

    try {
        // Call the Spotify Download API
        const apiResponse = await axios.get(`https://api.giftedtech.my.id/api/download/spotifydl`, {
            params: { apikey: "gifted-md", url: spotifyUrl }
        });

        if (apiResponse.status === 200 && apiResponse.data.success) {
            const track = apiResponse.data.result;

            const caption = `🎵 *Spotify Track Downloaded:*\n\n` +
                            `🔹 *Title:* ${track.title}\n` +
                            `⏱️ *Duration:* ${track.duration}\n` +
                            `🎧 *Quality:* ${track.quality}`;

            // Send the audio file to the user
            await bot.sendAudio(chatId, track.download_url, {
                caption: caption,
                parse_mode: "Markdown",
                thumb: track.thumbnail, // Optional: Thumbnail as album art
            });
        } else {
            bot.sendMessage(chatId, "❌ Failed to fetch track details. Please check the Spotify URL and try again.");
        }
    } catch (error) {
        console.error("Error in /spotify-download command:");
        bot.sendMessage(
            chatId,
            `⚠️ An error occurred:\n\n*Message:*`,
            { parse_mode: "Markdown" }
        );
    }
});


bot.onText(/\/(song)(?: (.+))?/, async (msg, match) => {
    const chatId = msg.chat.id;
    const query = match[2]; // Extract the search query from the command

    if (!query) {
        return bot.sendMessage(
            chatId,
            "❌ Please provide a search query.\n\n*Usage:* `/song <song title>`\n*Example:* `/song faded`",
            { parse_mode: "Markdown" }
        );
    }

    bot.sendMessage(chatId, "🔍 Searching for songs on Spotify... Please wait.");

    try {
        // Call the Spotify Search API
        const searchResponse = await axios.get(`https://api.giftedtech.my.id/api/search/spotifysearch`, {
            params: { apikey: "gifted", query: query }
        });

        if (searchResponse.status === 200 && searchResponse.data.success && searchResponse.data.results.length > 0) {
            const results = searchResponse.data.results;

            // Create inline keyboard buttons for the search results
            const buttons = results.slice(0, 10).map((item) => [
                { text: `${item.title} - ${item.artist}`, callback_data: `song_${item.id}` }
            ]);

            bot.sendMessage(chatId, "🎶 Select a song to download:", {
                reply_markup: {
                    inline_keyboard: buttons
                }
            });
        } else {
            bot.sendMessage(chatId, "❌ No songs found. Please try a different query.");
        }
    } catch (error) {
        console.error("Error in /song command:");
        bot.sendMessage(chatId, `⚠️ An error occurred:\n\n*Message:*`, { parse_mode: "Markdown" });
    }
});

// Handle button clicks for song selection
bot.on("callback_query", async (callbackQuery) => {
    const chatId = callbackQuery.message.chat.id;
    const data = callbackQuery.data;

    if (data.startsWith("song_")) {
        const trackId = data.split("_")[1];

        bot.sendMessage(chatId, "🔄 Downloading your song... Please wait.");

        try {
            // Call the Spotify Download API
            const downloadResponse = await axios.get(`https://api.giftedtech.my.id/api/download/spotifydl`, {
                params: { apikey: "gifted", url: `https://open.spotify.com/track/${trackId}` }
            });

            if (downloadResponse.status === 200 && downloadResponse.data.success) {
                const track = downloadResponse.data.result;

                // Send the audio file
                await bot.sendAudio(chatId, track.download_url, {
                    caption: `🔹 *Title:* ${track.title}\n` +
                             `⏱️ *Duration:* ${track.duration}\n` +
                             `🎧 *Quality:* ${track.quality}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
                    parse_mode: "Markdown",
                    thumb: track.thumbnail // Optional: Thumbnail as album art
                });
            } else {
                bot.sendMessage(chatId, "❌ Failed to download the song. Please try again.");
            }
        } catch (error) {
            console.error("Error during song download:");
            bot.sendMessage(chatId, `⚠️ An error occurred:\n\n*Message:*`, { parse_mode: "Markdown" });
        }
    }
});

// /facebook command
bot.onText(/\/(facebook|fb|fbdl|fbdownload)(?: (.+))?/, async (msg, match) => {
    const chatId = msg.chat.id;
    const text = match[2]; // Extract the Facebook video link from the command

    // Guide if no link is provided
    if (!text) {
        return bot.sendMessage(chatId, "❌ Please provide a Facebook video link.\nExample: `/fb https://www.facebook.com/reel/1256751708994400?mibextid=rS40aB7S9Ucbxw6v`");
    }

    // Notify user of processing
    bot.sendMessage(chatId, "🔄 Fetching your Facebook video... Please wait.");

    try {
        // Fetch video data using the new API
        const apiResponse = await axios.get('https://bk9.fun/download/fb', {
            params: { url: text },
        });

        const responseData = apiResponse.data;

        // Check if the API response is valid
        if (responseData.status && responseData.BK9) {
            const videoData = responseData.BK9;
            const hdLink = videoData.hd || videoData.sd; // Use HD link if available, fallback to SD
            const videoTitle = videoData.title || "Facebook Video";

            // Send the video file directly
            await bot.sendVideo(chatId, hdLink, {
                caption: `ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ`,
                parse_mode: 'Markdown',
            });
        } else {
            bot.sendMessage(chatId, "❌ Failed to fetch the video. Please check the link and try again.");
        }
    } catch (error) {
        console.error("Error in Facebook Downloader:");
        bot.sendMessage(chatId, "❌ An error occurred while processing your request. Please try again later.");
    }
});


// Temporary storage for mapping callback data to URLs
const twitterDownloadLinks = new Map();

bot.onText(/\/twitter (.+)/, async (msg, match) => {
    const chatId = msg.chat.id;
    const twitterUrl = match[1]?.trim();

    // Validate input
    if (!twitterUrl || !twitterUrl.startsWith("http")) {
        return bot.sendMessage(chatId, "❌ Please provide a valid Twitter link.\nExample: `/twitter https://x.com/elonmusk/status/1870904082564555012`");
    }

    // Notify user of processing
    bot.sendMessage(chatId, "🔄 Fetching Twitter media... Please wait.");

    try {
        // Fetch data from the API
        const apiUrl = `https://api.paxsenix.biz.id/dl/twitter?url=${encodeURIComponent(twitterUrl)}`;
        const response = await axios.get(apiUrl);
        const data = response.data;

        // Check if API returned valid data
        if (!data.ok) {
            return bot.sendMessage(chatId, "❌ Failed to fetch Twitter media. Please check the link and try again.");
        }

        // Generate unique identifiers for the buttons
        const uniqueIdHD = `HD_${Date.now()}`;
        const uniqueIdSD = `SD_${Date.now()}`;
        const uniqueIdAudio = `Audio_${Date.now()}`;

        // Store URLs in the mapping
        if (data.HD) twitterDownloadLinks.set(uniqueIdHD, data.HD);
        if (data.SD) twitterDownloadLinks.set(uniqueIdSD, data.SD);
        if (data.audio) twitterDownloadLinks.set(uniqueIdAudio, data.audio);

        // Inline keyboard for video quality selection
        const inlineKeyboard = [];
        if (data.HD) inlineKeyboard.push([{ text: "HD Video", callback_data: uniqueIdHD }]);
        if (data.SD) inlineKeyboard.push([{ text: "SD Video", callback_data: uniqueIdSD }]);
        if (data.audio) inlineKeyboard.push([{ text: "Audio Only", callback_data: uniqueIdAudio }]);

        // Send preview with inline buttons
        await bot.sendPhoto(chatId, data.thumb, {
            caption: `🌟 *ATOMIC TWITTER DOWNLOADER!*\n\n🎉 *ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*\n\nSelect the desired quality below:`,
            parse_mode: "Markdown",
            reply_markup: {
                inline_keyboard: inlineKeyboard,
            },
        });
    } catch (error) {
        console.error("Error in Twitter Downloader:");
        bot.sendMessage(chatId, "❌ An error occurred while processing your request. Please try again later.");
    }
});

// Handle callback queries for Twitter downloads
bot.on("callback_query", async (callbackQuery) => {
    const chatId = callbackQuery.message.chat.id;
    const data = callbackQuery.data;

    // Check if the callback data exists in the mapping
    const url = twitterDownloadLinks.get(data);
    if (url) {
        // Notify user that the download is in progress
        await bot.sendMessage(chatId, "📥 Downloading your media...");

        try {
            // Determine the type based on the callback data
            if (data.startsWith("HD") || data.startsWith("SD")) {
                await bot.sendVideo(chatId, url, { caption: `🎬ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ` });
            } else if (data.startsWith("Audio")) {
                await bot.sendAudio(chatId, url, { caption: "🎵 ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ!" });
            }

            // Remove the mapping after successful download
            twitterDownloadLinks.delete(data);
        } catch (error) {
            console.error(`Error sending media:`);
            await bot.sendMessage(chatId, "❌ Failed to send the requested media. Please try again later.");
        }
    } else {
        bot.sendMessage(chatId, "");
    }

    // Acknowledge the callback query to avoid timeout
    bot.answerCallbackQuery(callbackQuery.id);
});

// /instagram command
bot.onText(/\/(instagram|ig|igvideo|igimage|igdownload|instadl)(?: (.+))?/, async (msg, match) => {
    const chatId = msg.chat.id;
    const text = match[2]; // Extract the Instagram URL from the command

    // Guide if no link is provided
    if (!text || !text.startsWith('http')) {
        return bot.sendMessage(chatId, "❌ Please provide a valid Instagram link.\nExample: `/instagram https://www.instagram.com/reel/DDgvfkAuBMI/`");
    }

    // Notify user of processing
    bot.sendMessage(chatId, "🔄 Fetching your Instagram media... Please wait.");

    try {
        // Fetch Instagram media data using the API
        const apiResponse = await axios.get('https://api.paxsenix.biz.id/dl/ig', {
            params: { url: text },
        });

        const responseData = apiResponse.data;

        // Check if the API response is valid
        if (responseData.ok && responseData.url && responseData.url.length > 0) {
            const media = responseData.url[0]; // Assume the first item is the main media
            const mediaUrl = media.url;
            const mediaType = media.type || "video"; // Default to video

            if (mediaType === "video") {
                // Send the video
                await bot.sendVideo(chatId, mediaUrl, {
                    caption: `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
                    parse_mode: "Markdown",
                });
            } else {
                // Send the image
                await bot.sendPhoto(chatId, mediaUrl, {
                    caption: `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
                    parse_mode: "Markdown",
                });
            }
        } else {
            bot.sendMessage(chatId, "❌ Failed to fetch media. Please check the link and try again.");
        }
    } catch (error) {
        console.error("Error in Instagram Downloader:");
        bot.sendMessage(chatId, "❌ An error occurred while processing your request. Please try again later.");
    }
});
// Anti-link command
// Anti-link toggle commands (Admins only)
bot.onText(/\/antilink (on|off)/, async (msg, match) => {
    const chatId = msg.chat.id;
    const userId = msg.from.id;
    const action = match[1];

    // Check if the user is an admin
    if (await isAdmin(chatId, userId)) {
        if (action === 'on') {
            antiLinkActive = true;
            bot.sendMessage(chatId, "Anti-link is now activated!");
        } else if (action === 'off') {
            antiLinkActive = false;
            bot.sendMessage(chatId, "Anti-link is now deactivated!");
        }
    } else {
        bot.sendMessage(chatId, "You don't have permission to use this command.");
    }
});


bot.onText(/\/xvideodownload (.+)?/, async (msg, match) => {
  const chatId = msg.chat.id;
  const input = match[1]?.trim(); // Get the user-provided URL (if any)

  // Check for the last stored video URL or input
  const url = input || (global.db?.data?.users?.[msg.from.id]?.lastVideoUrl);
  if (!url) {
    return bot.sendMessage(chatId, "❌ *No video URL found!*\nPlease provide a valid video link or use `/videosearch` first.", {
      parse_mode: "Markdown",
    });
  }

  try {
    // Step 1: Call the video download API
    const apiUrl = `https://api.agatz.xyz/api/xvideodown?url=${encodeURIComponent(url)}`;
    const response = await axios.get(apiUrl);
    const result = response.data;

    // Step 2: Check if the API returned a valid response
    if (result.status === 200 && result.data?.url) {
      const videoStreamUrl = result.data.url;

      // Step 3: Download the video content
      const videoResponse = await axios({
        url: videoStreamUrl,
        method: 'GET',
        responseType: 'stream',
      });

      // Step 4: Send the video to the user
      const videoInfo = result.data;
      const body = `🎥 *Video Details:*\n\n` +
                   `🔤 *Title:* ${videoInfo.title}\n` +
                   `👀 *Views:* ${videoInfo.views}\n` +
                   `👍 *Likes:* ${videoInfo.like_count}\n` +
                   `👎 *Dislikes:* ${videoInfo.dislike_count}\n` +
                   `⭐ *Votes:* ${videoInfo.vote}\n` +
                   `🔗 *Source:* [Watch Original Video](${url})\n\n` +
                   `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ™*`;

      await bot.sendMessage(chatId, body, { parse_mode: "Markdown" });

      bot.sendVideo(chatId, videoResponse.data, {
        caption: `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
        parse_mode: "Markdown",
      });
    } else {
      bot.sendMessage(chatId, "❌ Failed to fetch the video. Please try again later.");
    }
  } catch (error) {
    console.error("Video Download Error:");
    bot.sendMessage(chatId, "❌ An error occurred while downloading the video. Please try again.");
  }
});

bot.onText(/\/videodownload (.+)?/, async (msg, match) => {
  const chatId = msg.chat.id;
  const input = match[1]?.trim(); // Get the user-provided URL (if any)

  // Check for the last stored video URL or input
  const url = input || (global.db?.data?.users?.[msg.from.id]?.lastVideoUrl);
  if (!url) {
    return bot.sendMessage(chatId, "❌ *No video URL found!*\nPlease provide a valid video link or use `/xvideosearch` first.", {
      parse_mode: "Markdown",
    });
  }

  try {
    // Step 1: Call the video download API
    const apiUrl = `https://api.agatz.xyz/api/xvideodown?url=${encodeURIComponent(url)}`;
    const response = await axios.get(apiUrl);
    const result = response.data;

    // Step 2: Check if the API returned a valid response
    if (result.status === 200 && result.data?.url) {
      const videoInfo = result.data;
      const videoUrl = videoInfo.url;

      // Step 3: Prepare the video details for the user
      const body = `🎥 *Video Details:*\n\n` +
                   `🔤 *Title:* ${videoInfo.title}\n` +
                   `👀 *Views:* ${videoInfo.views}\n` +
                   `👍 *Likes:* ${videoInfo.like_count}\n` +
                   `👎 *Dislikes:* ${videoInfo.dislike_count}\n` +
                   `⭐ *Votes:* ${videoInfo.vote}\n` +
                   `🔗 *URL:* [Watch Original Video](${url})\n\n` +
                   `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`;

      // Step 4: Send the video thumbnail and downloadable video to the user
      await bot.sendPhoto(chatId, videoInfo.thumb, {
        caption: body,
        parse_mode: "Markdown",
      });

      await bot.sendVideo(chatId, videoUrl, {
        caption: `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
        parse_mode: "Markdown",
      });
    } else {
      bot.sendMessage(chatId, "❌ Failed to fetch the video. Please try again later.");
    }
  } catch (error) {
    console.error("Video Download Error:");
    bot.sendMessage(chatId, "❌ An error occurred while downloading the video. Please try again.");
  }
});





const { randomUUID } = require("crypto");

// /text2speech command
bot.onText(/\/text2speech (.+)/, async (msg, match) => {
  const chatId = msg.chat.id;
  const input = match[1].trim();

  if (!input) {
    return bot.sendMessage(chatId, "❌ *Please provide text to convert to speech!*\nExample: `/text2speech Hello world | en`", {
      parse_mode: "Markdown",
    });
  }

  try {
    // Split input into text and optional language code
    const [text, lang] = input.split("|").map((item) => item.trim());
    const language = lang || "en"; // Default to 'en' if no language provided

    if (!text) {
      return bot.sendMessage(chatId, "❌ *Please provide valid text for the speech conversion.*", {
        parse_mode: "Markdown",
      });
    }

    const encodedText = encodeURIComponent(text);
    const apiUrl = `https://bk9.fun/tools/tts?q=${encodedText}&lang=${language}`;

    // Step 1: Fetch the audio file
    const response = await axios({
      method: "GET",
      url: apiUrl,
      responseType: "stream",
    });

    // Generate a random filename for the audio
    const fileName = `${randomUUID()}.mp3`;
    const filePath = `./${fileName}`;

    // Step 2: Save the audio stream to a file
    const writer = fs.createWriteStream(filePath);
    response.data.pipe(writer);

    writer.on("finish", async () => {
      try {
        // Step 3: Send the audio file to the user
        await bot.sendAudio(chatId, filePath, {
          caption: `🎙️ *Text-to-Speech Result*\n🌐 *Language:* ${language.toUpperCase()}`,
          parse_mode: "Markdown",
        });

        // Cleanup: Delete the temporary file
        fs.unlinkSync(filePath);
        console.log(`Temporary file ${fileName} deleted successfully.`);
      } catch (sendError) {
        console.error("Error sending TTS file:");
        bot.sendMessage(chatId, "❌ Failed to send the generated audio file.");
        if (fs.existsSync(filePath)) fs.unlinkSync(filePath); // Ensure cleanup
      }
    });

    writer.on("error", (error) => {
      console.error("Error saving TTS file:");
      bot.sendMessage(chatId, "❌ Failed to generate or send the audio.");
    });
  } catch (error) {
    console.error("TTS Error:");
    bot.sendMessage(chatId, "❌ An error occurred while generating speech. Please try again.");
  }
});




// /dog command
bot.onText(/\/dog/, async (msg) => {
    const chatId = msg.chat.id;

    try {
        const response = await axios.get('https://dog.ceo/api/breeds/image/random');
        const dogUrl = response.data.message;
        bot.sendPhoto(chatId, dogUrl);
    } catch (error) {
        bot.sendMessage(chatId, 'Could not fetch a dog picture at the moment. Please try again later.');
    }
});





// Function to get currency conversion rate from ExchangeRate-API
async function getCurrencyConversion(amount, fromCurrency, toCurrency) {
  try {
    // Request currency conversion data from ExchangeRate-API
    const response = await axios.get(`https://v6.exchangerate-api.com/v6/${apiKey}/latest/${fromCurrency}`);

    const rates = response.data.conversion_rates;
    const conversionRate = rates[toCurrency];

    if (conversionRate) {
      const convertedAmount = (amount * conversionRate).toFixed(2);
      return `${amount} ${fromCurrency} = ${convertedAmount} ${toCurrency}`;
    } else {
      return `Sorry, I couldn't find the conversion rate for ${toCurrency}.`;
    }
  } catch (error) {
    console.error('Error fetching currency conversion:');
    return 'Oops! Something went wrong. Please try again later.';
  }
}

// Command handler for /currency
bot.onText(/\/currency (\d+\.?\d*) (\w+) to (\w+)/, async (msg, match) => {
  const chatId = msg.chat.id;
  const amount = parseFloat(match[1]);
  const fromCurrency = match[2].toUpperCase();
  const toCurrency = match[3].toUpperCase();

  // Validate the amount
  if (isNaN(amount) || amount <= 0) {
    bot.sendMessage(chatId, 'Please provide a valid amount to convert. Example: /currency 100 USD to EUR');
    return;
  }

  const conversionResult = await getCurrencyConversion(amount, fromCurrency, toCurrency);
  bot.sendMessage(chatId, conversionResult);
});





// Flag to indicate when an admin has issued /setgrouppic
let awaitingGroupPic = new Map();

// /setgrouppic command (admins only)
bot.onText(/\/setgrouppic/, async (msg) => {
    const chatId = msg.chat.id;
    const userId = msg.from.id;

    if (msg.chat.type !== 'group' && msg.chat.type !== 'supergroup') {
        bot.sendMessage(chatId, 'This command can only be used in group chats.');
        return;
    }

    // Check if the user is an admin
    if (await isAdmin(chatId, userId)) {
        bot.sendMessage(chatId, 'Please send the new group picture as a photo.');
        awaitingGroupPic.set(chatId, userId); // Track the admin who issued the command
    } else {
        bot.sendMessage(chatId, "You don't have permission to use this command.");
    }
});

// Handle photo uploads for /setgrouppic
bot.on('photo', async (msg) => {
    const chatId = msg.chat.id;
    const userId = msg.from.id;

    // Check if we are awaiting a photo from an admin
    if (awaitingGroupPic.get(chatId) === userId) {
        const photoId = msg.photo[msg.photo.length - 1].file_id;

        try {
            const file = await bot.getFile(photoId);
            const downloadPath = await bot.downloadFile(photoId, './');

            await bot.setChatPhoto(chatId, fs.createReadStream(downloadPath));
            bot.sendMessage(chatId, 'Group picture updated successfully!');

            // Clean up
            fs.unlinkSync(downloadPath);
            awaitingGroupPic.delete(chatId); // Remove the flag after setting the picture
        } catch (error) {
            console.error('Error:');
            bot.sendMessage(chatId, 'Failed to update group picture. Make sure I have the required permissions.');
        }
    }
});

// Kick command
bot.onText(/\/kick/, async (msg) => {
    const chatId = msg.chat.id;

    if (msg.reply_to_message) {
        const userId = msg.reply_to_message.from.id; // User to kick must be mentioned in reply
        const requesterId = msg.from.id; // ID of the person issuing the command

        if (await isAdmin(chatId, requesterId)) {
            try {
                await bot.kickChatMember(chatId, userId);
                bot.sendMessage(chatId, "User has been kicked.");
                // Optionally, unban the user immediately to allow them to rejoin if necessary
                setTimeout(() => {
                    bot.unbanChatMember(chatId, userId);
                }, 1000);
            } catch (err) {
                console.error("Failed to kick user:");
                bot.sendMessage(chatId, "Failed to kick user. Ensure I have appropriate permissions.");
            }
        } else {
            bot.sendMessage(chatId, "You don't have permission to use this command.");
        }
    } else {
        bot.sendMessage(chatId, "Please reply to a user's message to kick them.");
    }
});

// Mute command
// Mute command
bot.onText(/\/mute/, async (msg) => {
    const chatId = msg.chat.id;
    const requesterId = msg.from.id;

    // Check if the user issuing the command is an admin
    if (await isAdmin(chatId, requesterId)) {
        if (msg.reply_to_message) {
            const userId = msg.reply_to_message.from.id; // User to mute must be mentioned in reply
            mutedUsers.add(userId);
            bot.sendMessage(chatId, `User has been muted.`);
        } else {
            bot.sendMessage(chatId, "Please reply to a user's message to mute them.");
        }
    } else {
        bot.sendMessage(chatId, "You don't have permission to use this command.");
    }
});

// Function to get anime details from Jikan API
async function getAnimeInfo(animeName) {
  try {
    const response = await axios.get(`https://api.jikan.moe/v4/anime?q=${animeName}&limit=1`);
    const anime = response.data.data[0];
    if (anime) {
      const title = anime.title;
      const synopsis = anime.synopsis;
      const rating = anime.rating;
      const imageUrl = anime.images.jpg.image_url;
      const url = anime.url;

      return {
        info: `*${title}*\n\n${synopsis}\n\n*Rating:* ${rating}\n\n[More Info](${url})`,
        imageUrl: imageUrl,
      };
    } else {
      return { info: 'No anime found with that name.', imageUrl: null };
    }
  } catch (error) {
    console.error('Error fetching anime info:');
    return { info: 'Oops! Something went wrong.', imageUrl: null };
  }
}

// Command handler for /anime
bot.onText(/\/anime (.+)/, async (msg, match) => {
  const chatId = msg.chat.id;
  const animeName = match[1];

  const { info, imageUrl } = await getAnimeInfo(animeName);

  // Send the information as a message
  bot.sendMessage(chatId, info, { parse_mode: 'Markdown' });

  // If an image URL is available, send the image
  if (imageUrl) {
    bot.sendPhoto(chatId, imageUrl);
  }
});



// Unmute command
bot.onText(/\/unmute/, (msg) => {
    const chatId = msg.chat.id;
    if (msg.reply_to_message) {
        const userId = msg.reply_to_message.from.id; // User to unmute must be mentioned in reply
        mutedUsers.delete(userId);
        bot.sendMessage(chatId, `User has been unmuted.`);
    } else {
        bot.sendMessage(chatId, "Please reply to a user's message to unmute them.");
    }
});

// Promote command
bot.onText(/\/promote/, async (msg) => {
    const chatId = msg.chat.id;
    if (msg.reply_to_message) {
        const userId = msg.reply_to_message.from.id; // User to promote must be mentioned in reply
        if (await isAdmin(chatId, msg.from.id)) {
            try {
                await bot.promoteChatMember(chatId, userId, {
                    can_change_info: true,
                    can_post_messages: true,
                    can_edit_messages: true,
                    can_delete_messages: true,
                    can_invite_users: true,
                    can_restrict_members: true,
                    can_pin_messages: true,
                    can_promote_members: true
                });
                bot.sendMessage(chatId, "User has been promoted to admin.");
            } catch (err) {
                bot.sendMessage(chatId, "Failed to promote user.");
            }
        } else {
            bot.sendMessage(chatId, "You don't have permission to use this command.");
        }
    } else {
        bot.sendMessage(chatId, "Please reply to a user's message to promote them.");
    }
});

// Demote command
bot.onText(/\/demote/, async (msg) => {
    const chatId = msg.chat.id;
    if (msg.reply_to_message) {
        const userId = msg.reply_to_message.from.id; // User to demote must be mentioned in reply
        if (await isAdmin(chatId, msg.from.id)) {
            try {
                await bot.promoteChatMember(chatId, userId, {
                    can_change_info: false,
                    can_post_messages: false,
                    can_edit_messages: false,
                    can_delete_messages: false,
                    can_invite_users: false,
                    can_restrict_members: false,
                    can_pin_messages: false,
                    can_promote_members: false
                });
                bot.sendMessage(chatId, "User has been demoted.");
            } catch (err) {
                bot.sendMessage(chatId, "Failed to demote user.");
            }
        } else {
            bot.sendMessage(chatId, "You don't have permission to use this command.");
        }
    } else {
        bot.sendMessage(chatId, "Please reply to a user's message to demote them.");
    }
});

// Set name command
bot.onText(/\/setname (.+)/, async (msg, match) => {
    const chatId = msg.chat.id;
    const newName = match[1];
    if (await isAdmin(chatId, msg.from.id)) {
        try {
            await bot.setChatTitle(chatId, newName);
            bot.sendMessage(chatId, `Group name has been changed to "${newName}".`);
        } catch (err) {
            bot.sendMessage(chatId, "Failed to change group name.");
        }
    } else {
        bot.sendMessage(chatId, "You don't have permission to use this command.");
    }
});

// /meme command
bot.onText(/\/meme/, async (msg) => {
    const chatId = msg.chat.id;

    try {
        const response = await axios.get('https://meme-api.herokuapp.com/gimme');
        const memeUrl = response.data.url;
        bot.sendPhoto(chatId, memeUrl);
    } catch (error) {
        bot.sendMessage(chatId, 'Could not retrieve a meme at the moment. Please try again later.');
    }
});

// /joke command
bot.onText(/\/joke/, async (msg) => {
    const chatId = msg.chat.id;
    try {
        const response = await axios.get('https://official-joke-api.appspot.com/random_joke');
        const joke = `${response.data.setup} - ${response.data.punchline}`;
        bot.sendMessage(chatId, joke);
    } catch (error) {
        bot.sendMessage(chatId, 'Failed to fetch a joke. Please try again later.');
    }
});




// /text2pdf command
bot.onText(/\/text2pdf (.+)/, async (msg, match) => {
  const chatId = msg.chat.id;
  const inputText = match[1].trim();

  if (!inputText) {
    return bot.sendMessage(
      chatId,
      "❌ *Please provide the text to convert into a PDF!*\nExample: `/text2pdf Hello, this is a test.`",
      { parse_mode: "Markdown" }
    );
  }

  try {
    // Encode the text to be sent in the URL
    const encodedText = encodeURIComponent(inputText);
    const pdfUrl = `https://bk9.fun/tools/pdf?q=${encodedText}`;

    // Step 1: Fetch the PDF file
    const response = await axios({
      method: "GET",
      url: pdfUrl,
      responseType: "stream",
    });

    // Generate a random file name for the PDF
    const fileName = `document_${Date.now()}.pdf`;
    const filePath = `./${fileName}`;

    // Step 2: Save the PDF stream to a file
    const writer = require("fs").createWriteStream(filePath);
    response.data.pipe(writer);

    writer.on("finish", async () => {
      // Step 3: Send the PDF file to the user
      await bot.sendDocument(chatId, filePath, {
        caption: `✅ Your PDF file has been generated successfully!\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
        parse_mode: "Markdown",
      });

      // Cleanup: Delete the temporary file
      require("fs").unlinkSync(filePath);
      console.log(`Temporary file ${fileName} deleted successfully.`);
    });

    writer.on("error", (error) => {
      console.error("Error saving PDF file:");
      bot.sendMessage(chatId, "❌ Failed to generate or send the PDF file.");
    });
  } catch (error) {
    console.error("PDF Generation Error:");
    bot.sendMessage(chatId, "❌ An error occurred while generating the PDF. Please try again.");
  }
});


bot.onText(/\/xvideosearch (.+)/, async (msg, match) => {
  const chatId = msg.chat.id;
  const query = match[1].trim();

  if (!query) {
    return bot.sendMessage(chatId, "❌ *Please provide a search query!*\nExample: `/xvideosearch step sister`", {
      parse_mode: "Markdown",
    });
  }

  try {
    // Step 1: Call the video search API
    const apiUrl = `https://api.agatz.xyz/api/xvideo?message=${encodeURIComponent(query)}`;
    const response = await axios.get(apiUrl);
    const result = response.data;

    // Step 2: Check if results exist
    if (result.status === 200 && result.data.length > 0) {
      const videoInfo = result.data[0]; // Get the first video result

      // Step 3: Prepare the message body
      const body = `🎥 *Video Search Result:*\n\n` +
                   `🔤 *Title:* ${videoInfo.title}\n` +
                   `⏱️ *Duration:* ${videoInfo.duration}\n\nᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ`;

      // Step 4: Add an inline keyboard button with the video link
      const options = {
        parse_mode: "Markdown",
        reply_markup: {
          inline_keyboard: [
            [
              {
                text: "🔗 Watch Video",
                url: videoInfo.url,
              },
            ],
          ],
        },
      };

      // Step 5: Send the video thumbnail and details to the user with the button
      await bot.sendPhoto(chatId, videoInfo.thumb, {
        caption: body,
        ...options,
      });
    } else {
      bot.sendMessage(chatId, "❌ No results found. Please try a different query.");
    }
  } catch (error) {
    console.error("Video Search Error:");
    bot.sendMessage(chatId, "❌ An error occurred while fetching the search results. Please try again.");
  }
});

// Tag all command
bot.onText(/\/tagall/, async (msg) => {
    const chatId = msg.chat.id;
    if (await isAdmin(chatId, msg.from.id)) {
        const members = await bot.getChatAdministrators(chatId);
        const memberMentions = members.map(member => {
            return member.user.username ? `@${member.user.username}` : member.user.first_name;
        }).join(', ');
        
        bot.sendMessage(chatId, `Tagging all members:\n${memberMentions}`);
    } else {
        bot.sendMessage(chatId, "You don't have permission to use this command.");
    }
});

// Define the /Aza command
bot.onText(/\/support/, (msg) => {
    const chatId = msg.chat.id;
    const response = "9066528353 OPAY 🇳🇬\nPlease support Developer.";

    // Send the message
    bot.sendMessage(chatId, response);
});

// Define the /owner command
bot.onText(/\/owner/, (msg) => {
    const chatId = msg.chat.id;
    const response = "@deecee_x";

    // Send the message
    bot.sendMessage(chatId, response);
});

// /setdescription command
bot.onText(/\/setdescription (.+)/, (msg, match) => {
  const chatId = msg.chat.id;
  const description = match[1];

  if (msg.chat.type !== 'group' && msg.chat.type !== 'supergroup') {
    bot.sendMessage(chatId, 'This command can only be used in group chats.');
    return;
  }

  // Check if the user is an admin
  bot.getChatMember(chatId, msg.from.id).then(member => {
    if (member.status === 'administrator' || member.status === 'creator') {
      bot.setChatDescription(chatId, description)
        .then(() => {
          bot.sendMessage(chatId, 'Group description updated successfully!');
        })
        .catch((error) => {
          console.error('Error:');
          bot.sendMessage(chatId, 'Failed to update group description. Make sure I have the required permissions.');
        });
    } else {
      bot.sendMessage(chatId, 'Only group admins can use this command.');
    }
  }).catch(error => {
    console.error('Error fetching chat member:');
    bot.sendMessage(chatId, 'An error occurred while verifying your admin status.');
  });
});

// Get link command
bot.onText(/\/getlink/, async (msg) => {
    const chatId = msg.chat.id;
    if (await isAdmin(chatId, msg.from.id)) {
        try {
            const link = await bot.exportChatInviteLink(chatId);
            bot.sendMessage(chatId, `Here is your invite link: ${link}`);
        } catch (err) {
            bot.sendMessage(chatId, "Failed to get the invite link.");
        }
    } else {
        bot.sendMessage(chatId, "You don't have permission to use this command.");
    }
});

// Welcome and goodbye messages
bot.on('new_chat_members', (msg) => {
    const chatId = msg.chat.id;
    msg.new_chat_members.forEach(user => {
        bot.sendMessage(chatId, `Welcome ${user.first_name} to the group!`);
    });
});

bot.on('left_chat_member', (msg) => {
    const chatId = msg.chat.id;
    const user = msg.left_chat_member;
    bot.sendMessage(chatId, `${user.first_name} has left the group.`);
});

// Anti-link functionality
bot.on('message', (msg) => {
    const chatId = msg.chat.id;

    // Check if anti-link is active
    if (antiLinkActive && msg.entities) {
        msg.entities.forEach(entity => {
            if (entity.type === "url") {
                bot.deleteMessage(chatId, msg.message_id)
                    .then(() => {
                        bot.sendMessage(chatId, "Links are not allowed in this group.");
                    })
                    .catch(err => {
                        console.error("Failed to delete message:");
                    });
            }
        });
    }

    // Mute functionality
    if (mutedUsers.has(msg.from.id)) {
        bot.deleteMessage(chatId, msg.message_id)
            .catch(err => {
                console.error("Failed to delete muted user message:");
            });
    }
});






bot.onText(/\/txt2image (.+)/, async (msg, match) => {
    const chatId = msg.chat.id;
    const prompt = match[1]; // Extract the prompt from the command

    // Check if the user provided a prompt
    if (!prompt) {
        return bot.sendMessage(chatId, "❌ *Please provide a prompt!* \n\nUsage: `/magicstudio <prompt>`", { parse_mode: "Markdown" });
    }

    try {
        // Inform the user the process has started
        await bot.sendMessage(chatId, "✨ *Generating image... Please wait!*", { parse_mode: "Markdown" });

        // API URL to generate the image
        const apiUrl = `https://bk9.fun/ai/magicstudio?prompt=${encodeURIComponent(prompt)}`;

        // Fetch the generated image from the API
        const response = await axios.get(apiUrl, { responseType: "stream" });

        // Send the image back to the user
        await bot.sendPhoto(chatId, response.data, {
            caption: `🖼️ *Here's your generated image for:* \`${prompt}\`\n\nᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ`,
            parse_mode: "Markdown"
        });

    } catch (error) {
        console.error("Error generating image:");
        bot.sendMessage(chatId, "❌ *Failed to generate the image. Please try again later!*", { parse_mode: "Markdown" });
    }
});






bot.onText(/\/flux(?: (.+))?/, async (msg, match) => {
    const chatId = msg.chat.id;
    const prompt = match[1]; // Extract the user's prompt from the command

    if (!prompt) {
        // If no prompt is provided, send a usage guide
        return bot.sendMessage(chatId, "❌ Please provide a prompt to generate an image.\n\nExample: `/flux cat`", { parse_mode: "Markdown" });
    }

    bot.sendMessage(chatId, "🔄 Generating your image... Please wait.");

    try {
        // Call the Flux API to generate the image
        const apiUrl = `https://apis.davidcyriltech.my.id/flux?prompt=${encodeURIComponent(prompt)}`;
        
        // Send the generated image to the user
        await bot.sendPhoto(chatId, apiUrl, {
            caption: `✨ *Flux Image Generated*\n\n🔹 *Prompt:* ${prompt}\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
            parse_mode: "Markdown",
        });
    } catch (error) {
        console.error("Error during /flux command:");
        bot.sendMessage(chatId, "❌ An error occurred while generating the image. Please try again later.");
    }
});


const { shannzCdn } = require("./uploader"); // Import new uploader module

bot.on("message", async (msg) => {
  const chatId = msg.chat.id;
  const text = msg.text?.trim().toLowerCase();

  if (text === "remini" && msg.reply_to_message?.photo) {
    try {
      await bot.sendMessage(chatId, "⏳ Processing your image...");

      // Step 1: Download Image from Telegram
      const fileId = msg.reply_to_message.photo[msg.reply_to_message.photo.length - 1].file_id;
      const file = await bot.getFile(fileId);
      const fileUrl = `https://api.telegram.org/file/bot${process.env.BOT_TOKEN}/${file.file_path}`;
      const localFilePath = path.join(__dirname, "downloads", `${fileId}.jpg`);

      const writer = fs.createWriteStream(localFilePath);
      const imageResponse = await axios({ url: fileUrl, method: "GET", responseType: "stream" });
      imageResponse.data.pipe(writer);

      await new Promise((resolve, reject) => {
        writer.on("finish", resolve);
        writer.on("error", reject);
      });

      // Step 2: Upload Image to Shannz CDN
      const uploadResponse = await shannzCdn(localFilePath);
      console.log("Shannz CDN Response:", uploadResponse);

      if (!uploadResponse || !uploadResponse.url) {
        fs.unlinkSync(localFilePath);
        return bot.sendMessage(chatId, "❌ Failed to upload the image. Please try again.");
      }

      const imageUrl = uploadResponse.url;
      console.log("Uploaded Image URL:", imageUrl);

      // Step 3: Send Image to Remini API
      const enhanceUrl = `https://bk9.fun/tools/enhance?url=${encodeURIComponent(imageUrl)}`;
      console.log("Enhancement API URL:", enhanceUrl);

      // Step 4: Send Enhanced Image to User
      await bot.sendPhoto(chatId, enhanceUrl, {
        caption: "✨ *Image Enhanced Successfully!*",
        parse_mode: "Markdown",
      });

      fs.unlinkSync(localFilePath); // Cleanup
    } catch (error) {
      console.error("Error enhancing image:");
      bot.sendMessage(chatId, `❌ Error`);
    }
  }
});
// Handle /delete Command
bot.onText(/\/delete/, async (msg) => {
  const chatId = msg.chat.id;

  if (msg.reply_to_message) {
    try {
      await bot.deleteMessage(chatId, msg.reply_to_message.message_id);
      await bot.deleteMessage(chatId, msg.message_id);
    } catch (error) {
      bot.sendMessage(chatId, "❌ Unable to delete the message. Check my permissions.");
    }
  } else {
    bot.sendMessage(chatId, "❌ Please reply to a message to delete it.");
  }
});
// Delete Message Command
bot.onText(/\/delete/, async (msg) => {
  const chatId = msg.chat.id;

  if (msg.reply_to_message) {
    const messageId = msg.reply_to_message.message_id;

    try {
      // Delete the replied message
      await bot.deleteMessage(chatId, messageId);
      // Optionally delete the command message
      await bot.deleteMessage(chatId, msg.message_id);

      // Confirmation message
      await bot.sendMessage(chatId, "✅ Message deleted successfully.", { reply_to_message_id: msg.message_id });
    } catch (error) {
      console.error("Delete message error:");
      bot.sendMessage(
        chatId,
        "❌ Failed to delete the message. Ensure I have the necessary permissions.",
        { reply_to_message_id: msg.message_id }
      );
    }
  } else {
    bot.sendMessage(chatId, "❌ Please reply to the message you want to delete.", { reply_to_message_id: msg.message_id });
  }
});

// Start the bot
bot.onText(/\/help/, (msg) => {
    const chatId = msg.chat.id;
    bot.sendMessage(chatId, "Hi I Am Atomic! Use /start for available commands.");
});

// Store the start time when the bot starts
const startTime = Date.now();

// Command to get bot runtime
bot.onText(/\/runtime/, (msg) => {
    const chatId = msg.chat.id;
  
    // Calculate runtime
    const uptimeMs = Date.now() - startTime;
    const uptimeSeconds = Math.floor(uptimeMs / 1000);
    const hours = Math.floor(uptimeSeconds / 3600);
    const minutes = Math.floor((uptimeSeconds % 3600) / 60);
    const seconds = uptimeSeconds % 60;

    // Send back the bot runtime
    bot.sendMessage(chatId, `The bot has been running for ${hours} hours, ${minutes} minutes, and ${seconds} seconds.`);
});

// /ping command
bot.onText(/\/ping/, (msg) => {
  const chatId = msg.chat.id;
  const start = Date.now(); // Record the start time

  bot.sendMessage(chatId, 'Pong!').then(() => {
    const end = Date.now(); // Record the end time
    const ping = end - start; // Calculate the difference in milliseconds
    bot.sendMessage(chatId, `Response time: ${ping} ms`);
  });
});

// Unified /start command
bot.onText(/\/start/, (msg) => {
    const chatId = msg.chat.id;

    // First page: Download Commands
    const helpMessageDownload = `
*🔥 ATOMIC BOT MENU 🔥*

⬇️ *Download Commands*:
- 🎶 /play <song name>: Download and play music from YouTube.
- 🎶 /song <song name>: Download and play music from Spotify.
- 🎥 /tiktok <link>: Download TikTok videos.
- 📸 /instagram <link>: Download Instagram media.
- 📘 /fb <link>: Download Facebook videos.
- 🎥 /video <song name>: Download Music Videos.
- 🎶 /ytmp3 <link>: Download Music Videos.
- 🎥 /ytmp4 <link>: Download and play music.
- 📦 /mediafire <link>: Downloads MediaFire Files
- 📦 /apk <app name>: Downloads Apk.
- 📦 /gitclone <llnk>: Downloads files from github
- 🎬 /movie <movie name>: Downloads movies.
- 🎬 /twitter <link>: Downloads twitter videos.
`;

    bot.sendMessage(chatId, helpMessageDownload, {
        parse_mode: 'Markdown',
        reply_markup: {
            inline_keyboard: [
                [{ text: "➡️ NEXT", callback_data: "help_next_1" }]
            ]
        }
    });
});

// Handle button clicks for pagination
bot.on('callback_query', (query) => {
    const chatId = query.message.chat.id;

    // First "NEXT" button (from Download Menu to Admin Commands)
    if (query.data === "help_next_1") {
        const helpMessageAdmin = `🤖 *AI Commands*:
- 🤖 /chatbot <on / off>: Interact with ai models without using any prefix
- 🤖 /gpt <query>: Get an AI-powered response.
- 🔊 /text2speech <text>: Convert text to speech.
- 🪄 /text2image <prompt>: Generates Any Ai Image of your choice.
- 🪄 /flux <prompt>: Generates Any Realistic Ai Images.
`;

        bot.editMessageText(helpMessageAdmin, {
            chat_id: chatId,
            message_id: query.message.message_id,
            parse_mode: 'Markdown',
            reply_markup: {
                inline_keyboard: [
                    [
                        { text: "⬅️ BACK", callback_data: "help_back_0" },
                        { text: "➡️ NEXT", callback_data: "help_next_2" }
                    ]
                ]
            }
        });
    }

    // Second "NEXT" button (from Admin Commands to AI Menu)
    if (query.data === "help_next_2") {
        const helpMessageAI = `
🛠️ *Admin Commands*:
- 👮‍♂️ /kick: Kick a user (reply to their message).
- 🤐 /mute: Mute a user (reply to their message).
- 🔓 /unmute: Unmute a user (reply to their message).
- 📈 /promote: Promote a user to admin (reply to their message).
- 📉 /demote: Demote an admin (reply to their message).
- 📝 /setname <new name>: Change the group name.
- 🔗 /getlink: Get the group invite link.
- 🚫 /antilink: Toggle anti-link feature.
- 🖼️ /setgrouppic: Change the group picture.
- ✏️ /setdescription <text>: Update group description.
`;

        bot.editMessageText(helpMessageAI, {
            chat_id: chatId,
            message_id: query.message.message_id,
            parse_mode: 'Markdown',
            reply_markup: {
                inline_keyboard: [
                    [
                        { text: "⬅️ BACK", callback_data: "help_back_1" },
                        { text: "➡️ NEXT", callback_data: "help_next_3" }
                    ]
                ]
            }
        });
    }

    // Third "NEXT" button (from AI Menu to Tools Menu)
    if (query.data === "help_next_3") {
        const helpMessageTools = `
🔧 *Special Menu*:
- 🥵 /xvideosearch: <query> searches for adult videos 
- 👙 /xvideodownload: <link> downloads adult videos 
`;

        bot.editMessageText(helpMessageTools, {
            chat_id: chatId,
            message_id: query.message.message_id,
            parse_mode: 'Markdown',
            reply_markup: {
                inline_keyboard: [
                    [
                        { text: "⬅️ BACK", callback_data: "help_back_2" },
                        { text: "➡️ NEXT", callback_data: "help_next_4" }
                    ]
                ]
            }
        });
    }
    
        // Third "NEXT" button (from AI Menu to Tools Menu)
    if (query.data === "help_next_4") {
        const helpMessageTools = `
🔧 *Tools Menu*:
- 📄 /txt2pdf: Convert text to PDF. (coming soon)
- 🖇️ /url: Coverts Video, Photo, any file to url
- 📸 /ss: screenshots a website 
- 😍 /remini: Enhances any low quality image 
- 🥰 /couplepp: sends couples pics
- 🖼️ /image: searchs for images on the internet 
- 🎙️ /shazam: identifies any music on a video or audio file
`;

        bot.editMessageText(helpMessageTools, {
            chat_id: chatId,
            message_id: query.message.message_id,
            parse_mode: 'Markdown',
            reply_markup: {
                inline_keyboard: [
                    [
                        { text: "⬅️ BACK", callback_data: "help_back_3" },
                        { text: "➡️ NEXT", callback_data: "help_next_5" }
                    ]
                ]
            }
        });
    }

    // Fourth "NEXT" button (from Tools Menu to Utility Commands)
    if (query.data === "help_next_5") {
        const helpMessageUtility = `
📊 *Utility Commands*:
- ⏳ /runtime: Check the bot's uptime.
- 🏓 /ping: Check bot's response time.
- 💸 /currency <amount> <from> to <to>: Convert currencies (e.g., /currency 100 USD to EUR).
- 🗑️ /delete: Delete a specific message (reply to it).
`;

        bot.editMessageText(helpMessageUtility, {
            chat_id: chatId,
            message_id: query.message.message_id,
            parse_mode: 'Markdown',
            reply_markup: {
                inline_keyboard: [
                    [
                        { text: "⬅️ BACK", callback_data: "help_back_4" },
                        { text: "➡️ NEXT", callback_data: "help_next_6" }
                    ]
                ]
            }
        });
    }

    // Fifth "NEXT" button (from Utility Commands to Other Commands)
    if (query.data === "help_next_6") {
        const helpMessageOther = `
🙋‍♂️ *Other Commands*:
- 👑 /owner: Show the owner details.
- 🤝 /support: Support the developer.
- 📢 /tagall: Tag all group members.
- 🚀 /start: Welcome message and introduction.
- ❓ /help: Show this help menu.

*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*
`;

        bot.editMessageText(helpMessageOther, {
            chat_id: chatId,
            message_id: query.message.message_id,
            parse_mode: 'Markdown',
            reply_markup: {
                inline_keyboard: [
                    [
                        { text: "⬅️ BACK", callback_data: "help_back_5" }
                    ]
                ]
            }
        });
    }

    // Handle "BACK" buttons
    if (query.data === "help_back_0") {
        bot.editMessageText(helpMessageDownload, {
            chat_id: chatId,
            message_id: query.message.message_id,
            parse_mode: 'Markdown',
            reply_markup: {
                inline_keyboard: [
                    [{ text: "➡️ NEXT", callback_data: "help_next_1" }]
                ]
            }
        });
    }

    if (query.data === "help_back_1") {
        const helpMessageAdmin = `
🛠️ *Admin Commands*:
- 👮‍♂️ /kick: Kick a user (reply to their message).
- 🤐 /mute: Mute a user (reply to their message).
- 🔓 /unmute: Unmute a user (reply to their message).
- 📈 /promote: Promote a user to admin (reply to their message).
- 📉 /demote: Demote an admin (reply to their message).
- 📝 /setname <new name>: Change the group name.
- 🔗 /getlink: Get the group invite link.
- 🚫 /antilink: Toggle anti-link feature.
- 🖼️ /setgrouppic: Change the group picture.
- ✏️ /setdescription <text>: Update group description.
`;

        bot.editMessageText(helpMessageAdmin, {
            chat_id: chatId,
            message_id: query.message.message_id,
            parse_mode: 'Markdown',
            reply_markup: {
                inline_keyboard: [
                    [
                        { text: "⬅️ BACK", callback_data: "help_back_0" },
                        { text: "➡️ NEXT", callback_data: "help_next_2" }
                    ]
                ]
            }
        });
    }

    if (query.data === "help_back_2") {
        const helpMessageAI = `
🤖 *AI Commands*:
- 🤖 /gpt <query>: Answers any question.
- 🔊 /text2speech <text>: Convert text to speech. (coming soon)
- 🔊 /text2speech <text>: Convert text to speech.
- 🪄 /text2image <prompt>: Generates Any Ai Image of your choice.
- 🪄 /flux <prompt>: Generates Any Realistic Ai Images.
`;

        bot.editMessageText(helpMessageAI, {
            chat_id: chatId,
            message_id: query.message.message_id,
            parse_mode: 'Markdown',
            reply_markup: {
                inline_keyboard: [
                    [
                        { text: "⬅️ BACK", callback_data: "help_back_1" },
                        { text: "➡️ NEXT", callback_data: "help_next_3" }
                    ]
                ]
            }
        });
    }

    if (query.data === "help_back_3") {
        const helpMessageTools = `
🔧 *Special Menu*:
- 🥵 /xvideosearch: <query> searches for adult videos 
- 👙 /xvideodownload: <link> downloads adult videos
`;

        bot.editMessageText(helpMessageTools, {
            chat_id: chatId,
            message_id: query.message.message_id,
            parse_mode: 'Markdown',
            reply_markup: {
                inline_keyboard: [
                    [
                        { text: "⬅️ BACK", callback_data: "help_back_2" },
                        { text: "➡️ NEXT", callback_data: "help_next_4" }
                    ]
                ]
            }
        });
    }
    

    if (query.data === "help_back_3") {
        const helpMessageTools = `
🔧 *Tools Menu*:
- 📄 /txt2pdf: Convert text to PDF.
- 🖇️ /url: Coverts Video, Photo, any file to url
- 😍 /remini: Enhances any low quality image 
- 🖼️ /image: searchs for images on the internet 
- 🎙️ /shazam: identifies any music on a video or audio file
`;

        bot.editMessageText(helpMessageTools, {
            chat_id: chatId,
            message_id: query.message.message_id,
            parse_mode: 'Markdown',
            reply_markup: {
                inline_keyboard: [
                    [
                        { text: "⬅️ BACK", callback_data: "help_back_2" },
                        { text: "➡️ NEXT", callback_data: "help_next_4" }
                    ]
                ]
            }
        });
    }

    if (query.data === "help_back_4") {
        const helpMessageUtility = `
📊 *Utility Commands*:
- ⏳ /runtime: Check the bot's uptime.
- 🏓 /ping: Check bot's response time.
- 💸 /currency <amount> <from> to <to>: Convert currencies (e.g., /currency 100 USD to EUR).
- 🗑️ /delete: Delete a specific message (reply to it).
`;

        bot.editMessageText(helpMessageUtility, {
            chat_id: chatId,
            message_id: query.message.message_id,
            parse_mode: 'Markdown',
            reply_markup: {
                inline_keyboard: [
                    [
                        { text: "⬅️ BACK", callback_data: "help_back_3" },
                        { text: "➡️ NEXT", callback_data: "help_next_5" }
                    ]
                ]
            }
        });
    }
});