Spaces:

DeeCeeXxx
/

mywork

Paused

App Files Files Community

mywork / bot.js

DeeCeeXxx's picture

Upload bot.js

9279357 verified 10 months ago

history blame contribute delete

94.8 kB

	// 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;

	// Basic HTML response for health check
	app.get('/', (req, res) => {
	res.send(`
	<html>
	<head>
	<title>Bot Status</title>
	</head>
	<body style="text-align: center; margin-top: 50px; font-family: Arial, sans-serif;">
	<h1 style="color: green;">✅ Connected to Telegram</h1>
	<p>Your bot is up and running!</p>
	</body>
	</html>
	`);
	});

	// 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" });
	}
	});





	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" });

	// Step 1: Search for the video
	const search = await yts(query);
	const video = search.all[0]; // Take the first result
	if (!video) {
	return bot.sendMessage(chatId, "❌ Video not found!");
	}

	// Step 2: Fetch video download link from the API
	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;
	const filePath = `./temp/${title.replace(/[^\w\s]/gi, '')}.mp4`;

	// Step 3: Download video locally
	const writer = fs.createWriteStream(filePath);
	const videoStream = await axios({
	url: download_url,
	method: 'GET',
	responseType: 'stream'
	});

	videoStream.data.pipe(writer);

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

	await bot.sendVideo(chatId, download_url, {
	caption: `🎬 Here is your video:\n🎥 ${title}\n\nᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ`,
	parse_mode: "Markdown"
	});
	// Step 5: Delete the file after sending
	fs.unlinkSync(filePath);
	} 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.");
	}
	});

	// /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`");
	}

	try {
	// Notify user that the bot is searching
	await bot.sendMessage(chatId, "🔍 Searching for your song...");

	// Perform a YouTube search
	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.");
	}

	// Fetch the song download link using the new API
	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;
	const filename = `./${video.title.replace(/[^a-zA-Z0-9]/g, "_")}.mp3`;

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

	// Download the audio file
	const writer = fs.createWriteStream(filename);
	const { data } = await axios({
	url: download_url,
	method: "GET",
	responseType: "stream",
	});

	data.pipe(writer);

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

	// Send the locally saved audio file
	await bot.sendAudio(chatId, filename, {
	caption: `🎧 Here's your song:\n🎵 Title: ${video.title}\n\nᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ`,
	parse_mode: "Markdown",
	});

	// Delete the file after sending
	fs.unlink(filename, (err) => {
	if (err) console.error("Error deleting file:", err);
	});
	} 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.");
	}
	});
	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" });

	// Fetch audio download link
	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;
	const filename = `./temp/${Date.now()}.mp3`;

	// Download the audio locally
	const audioResponse = await axios({
	url: download_url,
	method: "GET",
	responseType: "stream",
	});

	const writer = fs.createWriteStream(filename);
	audioResponse.data.pipe(writer);

	writer.on("finish", async () => {
	await bot.sendAudio(chatId, download_url, {
	caption: `🎧 ${title}\n\nᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ`,
	parse_mode: "Markdown"
	});

	fs.unlinkSync(filename); // Delete after sending
	});
	} 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.");
	}
	});

	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(/\/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" });

	// Fetch video download link
	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;
	const filename = `./temp/${Date.now()}.mp4`;

	// Download the video locally
	const videoResponse = await axios({
	url: download_url,
	method: "GET",
	responseType: "stream",
	});

	const writer = fs.createWriteStream(filename);
	videoResponse.data.pipe(writer);

	writer.on("finish", async () => {
	await bot.sendVideo(chatId, download_url, {
	caption: `🎬 ${title}\n\nᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ`,
	parse_mode: "Markdown"
	});

	fs.unlinkSync(filename); // Delete after sending
	});
	} 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.");
	}
	});


	const path = require("path");



	// Utility: Validate and fetch direct PixelDrain link
	async function getDirectPixelDrainLink(fileUrl) {
	try {
	const response = await axios.get(fileUrl, { maxRedirects: 0, validateStatus: (status) => status < 400 });
	return response.headers.location \|\| fileUrl; // Return direct link
	} catch (error) {
	console.error("Error validating PixelDrain link:");
	throw new Error("Invalid or inaccessible PixelDrain link.");
	}
	}

	// Utility: Download file from PixelDrain and save it locally
	async function downloadFile(fileUrl, downloadPath) {
	try {
	const response = await axios({
	url: fileUrl,
	method: "GET",
	responseType: "stream",
	});

	const writer = fs.createWriteStream(downloadPath);
	response.data.pipe(writer);

	return new Promise((resolve, reject) => {
	writer.on("finish", () => {
	console.log(`File downloaded to: ${downloadPath}`);
	resolve();
	});
	writer.on("error", (err) => {
	console.error("Download error:");
	reject(err);
	});
	});
	} catch (error) {
	console.error("Error downloading file:", );
	throw new Error("Failed to download file.");
	}
	}

	// Utility: Stream file directly to Telegram
	async function streamFileToTelegram(chatId, filePath, caption) {
	try {
	await bot.sendDocument(chatId, filePath, { caption: caption });
	console.log("File streamed successfully to Telegram.");
	} catch (error) {
	console.error("Error streaming file:");
	throw new Error("Failed to stream file to Telegram.");
	}
	}

	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\nUsage: `/image <query>`\nExample: `/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\nMessage:`,
	{ 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\nUsage: `/spotifysearch <query>`\nExample: `/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\nMessage:`,
	{ 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\nUsage: `/spotify-download <Spotify URL>`\nExample: `/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\nMessage:`,
	{ 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\nUsage: `/song <song title>`\nExample: `/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\nMessage:`, { 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\nMessage:`, { 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\nRating: ${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" }
	]
	]
	}
	});
	}
	});