feat: implement ₹10/month UPI subscription paywall with dual-action admin approval

Thunder/bot/plugins/stream.py

@@ -1,11 +1,11 @@
-# Thunder/bot/plugins/stream.py
-
-import asyncio
-import secrets
-from typing import Any, Dict, Optional
-
-from pyrogram import Client, enums, filters
-from pyrogram.errors import FloodWait, MessageNotModified, MessageDeleteForbidden, MessageIdInvalid
+# Thunder/bot/plugins/stream.py
+
+import asyncio
+import secrets
+from typing import Any, Dict, Optional
+
+from pyrogram import Client, enums, filters
+from pyrogram.errors import FloodWait, MessageNotModified, MessageDeleteForbidden, MessageIdInvalid
 from pyrogram.types import (InlineKeyboardButton, InlineKeyboardMarkup,
                             Message)
 
@@ -16,62 +16,91 @@ from Thunder.utils.canonical_files import get_or_create_canonical_file
 from Thunder.utils.database import db
 from Thunder.utils.decorators import (check_banned, get_shortener_status,
                                       require_token)
-from Thunder.utils.force_channel import force_channel_check
-from Thunder.utils.logger import logger
-from Thunder.utils.messages import (
-    MSG_BATCH_LINKS_READY, MSG_BUTTON_DOWNLOAD, MSG_BUTTON_START_CHAT,
-    MSG_BUTTON_STREAM_NOW, MSG_CRITICAL_ERROR, MSG_DM_BATCH_PREFIX,
-    MSG_DM_SINGLE_PREFIX, MSG_ERROR_DM_FAILED, MSG_ERROR_INVALID_NUMBER,
-    MSG_ERROR_NO_FILE, MSG_ERROR_NOT_ADMIN, MSG_ERROR_NUMBER_RANGE,
-    MSG_ERROR_PROCESSING_MEDIA, MSG_ERROR_REPLY_FILE, MSG_ERROR_START_BOT,
-    MSG_LINKS, MSG_NEW_FILE_REQUEST, MSG_PROCESSING_BATCH,
-    MSG_PROCESSING_FILE, MSG_PROCESSING_REQUEST, MSG_PROCESSING_RESULT,
-    MSG_PROCESSING_STATUS
-)
-from Thunder.utils.rate_limiter import handle_rate_limited_request
-from Thunder.vars import Var
-
-BATCH_SIZE = 10
-LINK_CHUNK_SIZE = 20
-BATCH_UPDATE_INTERVAL = 5
-MESSAGE_DELAY = 0.5
-
-
-async def fwd_media(m_msg: Message) -> Optional[Message]:
-    try:
-        try:
-            return await m_msg.copy(chat_id=Var.BIN_CHANNEL)
-        except FloodWait as e:
-            await asyncio.sleep(e.value)
-            return await m_msg.copy(chat_id=Var.BIN_CHANNEL)
-    except Exception as e:
-        if "MEDIA_CAPTION_TOO_LONG" in str(e):
-            logger.debug(f"MEDIA_CAPTION_TOO_LONG error, retrying without caption: {e}")
-            try:
-                return await m_msg.copy(chat_id=Var.BIN_CHANNEL, caption=None)
-            except FloodWait as e:
-                await asyncio.sleep(e.value)
-                return await m_msg.copy(chat_id=Var.BIN_CHANNEL, caption=None)
-        logger.error(f"Error fwd_media copy: {e}", exc_info=True)
-        return None
-
-
-def get_link_buttons(links):
-    return InlineKeyboardMarkup([[
-        InlineKeyboardButton(MSG_BUTTON_STREAM_NOW, url=links['stream_link']),
-        InlineKeyboardButton(MSG_BUTTON_DOWNLOAD, url=links['online_link'])
-    ]])
-
-async def validate_request_common(client: Client, message: Message) -> Optional[bool]:
-    if not await check_banned(client, message):
-        return None
-    if not await require_token(client, message):
-        return None
-    if not await force_channel_check(client, message):
-        return None
-    return await get_shortener_status(client, message)
-
-
+from Thunder.utils.force_channel import force_channel_check
+from Thunder.utils.logger import logger
+from Thunder.utils.messages import (
+    MSG_BATCH_LINKS_READY, MSG_PAYWALL_GATE, MSG_BUTTON_DOWNLOAD, MSG_BUTTON_START_CHAT,
+    MSG_BUTTON_STREAM_NOW, MSG_CRITICAL_ERROR, MSG_DM_BATCH_PREFIX,
+    MSG_DM_SINGLE_PREFIX, MSG_ERROR_DM_FAILED, MSG_ERROR_INVALID_NUMBER,
+    MSG_ERROR_NO_FILE, MSG_ERROR_NOT_ADMIN, MSG_ERROR_NUMBER_RANGE,
+    MSG_ERROR_PROCESSING_MEDIA, MSG_ERROR_REPLY_FILE, MSG_ERROR_START_BOT,
+    MSG_LINKS, MSG_NEW_FILE_REQUEST, MSG_PROCESSING_BATCH,
+    MSG_PROCESSING_FILE, MSG_PROCESSING_REQUEST, MSG_PROCESSING_RESULT,
+    MSG_PROCESSING_STATUS
+)
+from Thunder.utils.rate_limiter import handle_rate_limited_request
+from Thunder.vars import Var
+
+BATCH_SIZE = 10
+LINK_CHUNK_SIZE = 20
+BATCH_UPDATE_INTERVAL = 5
+MESSAGE_DELAY = 0.5
+
+
+async def fwd_media(m_msg: Message) -> Optional[Message]:
+    try:
+        try:
+            return await m_msg.copy(chat_id=Var.BIN_CHANNEL)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            return await m_msg.copy(chat_id=Var.BIN_CHANNEL)
+    except Exception as e:
+        if "MEDIA_CAPTION_TOO_LONG" in str(e):
+            logger.debug(f"MEDIA_CAPTION_TOO_LONG error, retrying without caption: {e}")
+            try:
+                return await m_msg.copy(chat_id=Var.BIN_CHANNEL, caption=None)
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                return await m_msg.copy(chat_id=Var.BIN_CHANNEL, caption=None)
+        logger.error(f"Error fwd_media copy: {e}", exc_info=True)
+        return None
+
+
+def get_link_buttons(links):
+    return InlineKeyboardMarkup([[
+        InlineKeyboardButton(MSG_BUTTON_STREAM_NOW, url=links['stream_link']),
+        InlineKeyboardButton(MSG_BUTTON_DOWNLOAD, url=links['online_link'])
+    ]])
+
+
+async def send_paywall_card(client: Client, message: Message, file_id: Optional[str] = None):
+    try:
+        user_id = message.from_user.id
+        from Thunder.bot.plugins.subscription import get_plan_keyboard
+        text = MSG_PAYWALL_GATE.format(
+            price=Var.SUB_PRICE,
+            upi_id=Var.UPI_ID
+        )
+        keyboard = get_plan_keyboard(user_id, file_id=file_id)
+        await message.reply_text(text, reply_markup=keyboard, quote=True)
+    except Exception as e:
+        logger.error(f"Error sending paywall card: {e}", exc_info=True)
+
+async def validate_request_common(client: Client, message: Message, file_identifier: Optional[str] = None) -> Optional[bool]:
+    if not await check_banned(client, message):
+        return None
+    if not await require_token(client, message):
+        return None
+    if not await force_channel_check(client, message):
+        return None
+
+    # Subscription / Payment Paywall Gate (Dormant by default)
+    if Var.PAYMENT_ENABLED and message.from_user:
+        user_id = message.from_user.id
+        is_owner = user_id == Var.OWNER_ID
+        is_admin_user = hasattr(Var, 'ADMINS') and user_id in Var.ADMINS
+        if not (is_owner or is_admin_user):
+            is_sub = await db.is_subscribed(user_id)
+            has_temp = False
+            if not is_sub and file_identifier:
+                has_temp = await db.has_temp_pass(user_id, file_identifier)
+            if not (is_sub or has_temp):
+                await send_paywall_card(client, message, file_id=file_identifier)
+                return None
+
+    return await get_shortener_status(client, message)
+
+
 async def send_channel_links(
     links: Dict[str, Any],
     source_info: str,
@@ -121,224 +150,230 @@ async def send_channel_links(
                 disable_web_page_preview=True,
                 reply_to_message_id=reply_to_message_id
             )
-
-
-async def safe_edit_message(message: Message, text: str, **kwargs):
-    try:
-        try:
-            return await message.edit_text(text, **kwargs)
-        except FloodWait as e:
-            await asyncio.sleep(e.value)
-            return await message.edit_text(text, **kwargs)
-    except MessageNotModified:
-        pass
-    except MessageDeleteForbidden:
-        logger.debug(f"Failed to edit message {message.id} due to permissions.")
-    except Exception as e:
-        logger.error(f"Error editing message {message.id}: {e}", exc_info=True)
-
-
-async def safe_delete_message(message: Message):
-    try:
-        try:
-            await message.delete()
-        except FloodWait as e:
-            await asyncio.sleep(e.value)
-            await message.delete()
-    except MessageDeleteForbidden:
-        logger.debug(f"Failed to delete message {message.id} due to permissions.")
-    except Exception as e:
-        logger.error(f"Error deleting message {message.id}: {e}", exc_info=True)
-
-
-async def send_dm_links(bot: Client, user_id: int, links: Dict[str, Any], chat_title: str):
-    try:
-        dm_text = MSG_DM_SINGLE_PREFIX.format(chat_title=chat_title) + "\n" + \
-                  MSG_LINKS.format(
-                      file_name=links['media_name'],
-                      file_size=links['media_size'],
-                      download_link=links['online_link'],
-                      stream_link=links['stream_link']
-                  )
-        try:
-            await bot.send_message(
-                chat_id=user_id,
-                text=dm_text,
-                disable_web_page_preview=True,
-                parse_mode=enums.ParseMode.MARKDOWN,
-                reply_markup=get_link_buttons(links)
-            )
-        except FloodWait as e:
-            await asyncio.sleep(e.value)
-            await bot.send_message(
-                chat_id=user_id,
-                text=dm_text,
-                disable_web_page_preview=True,
-                parse_mode=enums.ParseMode.MARKDOWN,
-                reply_markup=get_link_buttons(links)
-            )
-    except Exception as e:
-        logger.error(f"Error sending DM to user {user_id}: {e}", exc_info=True)
-
-
-async def send_link(msg: Message, links: Dict[str, Any]):
-    try:
-        await msg.reply_text(
-            MSG_LINKS.format(
-                file_name=links['media_name'],
-                file_size=links['media_size'],
-                download_link=links['online_link'],
-                stream_link=links['stream_link']
-            ),
-            quote=True,
-            parse_mode=enums.ParseMode.MARKDOWN,
-            disable_web_page_preview=True,
-            reply_markup=get_link_buttons(links)
-        )
-    except FloodWait as e:
-        await asyncio.sleep(e.value)
-        await msg.reply_text(
-            MSG_LINKS.format(
-                file_name=links['media_name'],
-                file_size=links['media_size'],
-                download_link=links['online_link'],
-                stream_link=links['stream_link']
-            ),
-            quote=True,
-            parse_mode=enums.ParseMode.MARKDOWN,
-            disable_web_page_preview=True,
-            reply_markup=get_link_buttons(links)
-        )
-
-
-@StreamBot.on_message(filters.command("link") & ~filters.private)
-async def link_handler(bot: Client, msg: Message, **kwargs):
-    async def _actual_link_handler(client: Client, message: Message, **handler_kwargs):
-        shortener_val = await validate_request_common(client, message)
-        if shortener_val is None:
-            return
-        if message.from_user and not await db.is_user_exist(message.from_user.id):
-            invite_link = f"https://t.me/{client.me.username}?start=start"
-            try:
-                await message.reply_text(
-                    MSG_ERROR_START_BOT.format(invite_link=invite_link),
-                    disable_web_page_preview=True,
-                    parse_mode=enums.ParseMode.MARKDOWN,
-                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_START_CHAT, url=invite_link)]]),
-                    quote=True
-                )
-            except FloodWait as e:
-                await asyncio.sleep(e.value)
-                await message.reply_text(
-                    MSG_ERROR_START_BOT.format(invite_link=invite_link),
-                    disable_web_page_preview=True,
-                    parse_mode=enums.ParseMode.MARKDOWN,
-                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_START_CHAT, url=invite_link)]]),
-                    quote=True
-                )
-            return
-
-        if (message.chat.type in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]
-                and not await is_admin(client, message.chat.id)):
-            await reply_user_err(message, MSG_ERROR_NOT_ADMIN)
-            return
-
-        if not message.reply_to_message or not message.reply_to_message.media:
-            await reply_user_err(
-                message,
-                MSG_ERROR_REPLY_FILE if not message.reply_to_message else MSG_ERROR_NO_FILE)
-            return
-
-        notification_msg = handler_kwargs.get('notification_msg')
-
-        parts = message.text.split()
-        num_files = 1
-        if len(parts) > 1:
-            try:
-                num_files = int(parts[1])
-                if not 1 <= num_files <= Var.MAX_BATCH_FILES:
-                    await reply_user_err(
-                        message,
-                        MSG_ERROR_NUMBER_RANGE.format(max_files=Var.MAX_BATCH_FILES))
-                    return
-            except ValueError:
-                await reply_user_err(message, MSG_ERROR_INVALID_NUMBER)
-                return
-
-        try:
-            status_msg = await message.reply_text(MSG_PROCESSING_REQUEST, quote=True)
-        except FloodWait as e:
-            await asyncio.sleep(e.value)
-            status_msg = await message.reply_text(MSG_PROCESSING_REQUEST, quote=True)
-        shortener_val = handler_kwargs.get('shortener', shortener_val)
-        if num_files == 1:
-            await process_single(client, message, message.reply_to_message, status_msg, shortener_val, notification_msg=notification_msg)
-        else:
-            await process_batch(client, message, message.reply_to_message.id, num_files, status_msg, shortener_val, notification_msg=notification_msg)
-
-    await handle_rate_limited_request(bot, msg, _actual_link_handler, **kwargs)
-
-
-@StreamBot.on_message(
-    filters.private &
-    filters.incoming &
-    (filters.document | filters.video | filters.photo | filters.audio |
-     filters.voice | filters.animation | filters.video_note),
-    group=4
-)
-async def private_receive_handler(bot: Client, msg: Message, **kwargs):
-    async def _actual_private_receive_handler(client: Client, message: Message, **handler_kwargs):
-        shortener_val = await validate_request_common(client, message)
-        if shortener_val is None:
-            return
-        if not message.from_user:
-            return
-
-        notification_msg = handler_kwargs.get('notification_msg')
-
-        await log_newusr(client, message.from_user.id, message.from_user.first_name or "")
-        try:
-            status_msg = await message.reply_text(MSG_PROCESSING_FILE, quote=True)
-        except FloodWait as e:
-            await asyncio.sleep(e.value)
-            status_msg = await message.reply_text(MSG_PROCESSING_FILE, quote=True)
-        await process_single(client, message, message, status_msg, shortener_val, notification_msg=notification_msg)
-
-    await handle_rate_limited_request(bot, msg, _actual_private_receive_handler, **kwargs)
-
-
-@StreamBot.on_message(
-    filters.channel &
-    filters.incoming &
-    (filters.document | filters.video | filters.audio) &
-    ~filters.chat(Var.BIN_CHANNEL),
-    group=-1
-)
-async def channel_receive_handler(bot: Client, msg: Message):
-    async def _actual_channel_receive_handler(client: Client, message: Message, **handler_kwargs):
-        if not Var.CHANNEL:
-            return
-        notification_msg = handler_kwargs.get('notification_msg')
-
-        is_banned_statically = hasattr(Var, 'BANNED_CHANNELS') and message.chat.id in Var.BANNED_CHANNELS
-        is_banned_dynamically = await db.is_channel_banned(message.chat.id) is not None
-
-        if is_banned_statically or is_banned_dynamically:
-            try:
-                try:
-                    await client.leave_chat(message.chat.id)
-                except FloodWait as e:
-                    await asyncio.sleep(e.value)
-                    await client.leave_chat(message.chat.id)
-            except Exception as e:
-                logger.error(f"Error leaving banned channel {message.chat.id}: {e}")
-            return
-        if not await is_admin(client, message.chat.id):
-            logger.debug(
-                f"Bot is not admin in channel {message.chat.id} "
-                f"({message.chat.title or 'Unknown'}). Ignoring message.")
-            return
-
+
+
+async def safe_edit_message(message: Message, text: str, **kwargs):
+    try:
+        try:
+            return await message.edit_text(text, **kwargs)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            return await message.edit_text(text, **kwargs)
+    except MessageNotModified:
+        pass
+    except MessageDeleteForbidden:
+        logger.debug(f"Failed to edit message {message.id} due to permissions.")
+    except Exception as e:
+        logger.error(f"Error editing message {message.id}: {e}", exc_info=True)
+
+
+async def safe_delete_message(message: Message):
+    try:
+        try:
+            await message.delete()
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await message.delete()
+    except MessageDeleteForbidden:
+        logger.debug(f"Failed to delete message {message.id} due to permissions.")
+    except Exception as e:
+        logger.error(f"Error deleting message {message.id}: {e}", exc_info=True)
+
+
+async def send_dm_links(bot: Client, user_id: int, links: Dict[str, Any], chat_title: str):
+    try:
+        dm_text = MSG_DM_SINGLE_PREFIX.format(chat_title=chat_title) + "\n" + \
+                  MSG_LINKS.format(
+                      file_name=links['media_name'],
+                      file_size=links['media_size'],
+                      download_link=links['online_link'],
+                      stream_link=links['stream_link']
+                  )
+        try:
+            await bot.send_message(
+                chat_id=user_id,
+                text=dm_text,
+                disable_web_page_preview=True,
+                parse_mode=enums.ParseMode.MARKDOWN,
+                reply_markup=get_link_buttons(links)
+            )
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await bot.send_message(
+                chat_id=user_id,
+                text=dm_text,
+                disable_web_page_preview=True,
+                parse_mode=enums.ParseMode.MARKDOWN,
+                reply_markup=get_link_buttons(links)
+            )
+    except Exception as e:
+        logger.error(f"Error sending DM to user {user_id}: {e}", exc_info=True)
+
+
+async def send_link(msg: Message, links: Dict[str, Any]):
+    try:
+        await msg.reply_text(
+            MSG_LINKS.format(
+                file_name=links['media_name'],
+                file_size=links['media_size'],
+                download_link=links['online_link'],
+                stream_link=links['stream_link']
+            ),
+            quote=True,
+            parse_mode=enums.ParseMode.MARKDOWN,
+            disable_web_page_preview=True,
+            reply_markup=get_link_buttons(links)
+        )
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        await msg.reply_text(
+            MSG_LINKS.format(
+                file_name=links['media_name'],
+                file_size=links['media_size'],
+                download_link=links['online_link'],
+                stream_link=links['stream_link']
+            ),
+            quote=True,
+            parse_mode=enums.ParseMode.MARKDOWN,
+            disable_web_page_preview=True,
+            reply_markup=get_link_buttons(links)
+        )
+
+
+@StreamBot.on_message(filters.command("link") & ~filters.private)
+async def link_handler(bot: Client, msg: Message, **kwargs):
+    async def _actual_link_handler(client: Client, message: Message, **handler_kwargs):
+        media = (
+            message.document or message.video or message.photo or
+            message.audio or message.voice or message.animation or message.video_note
+        )
+        file_unique_id = getattr(media, "file_unique_id", str(message.id)) if media else str(message.id)
+
+        shortener_val = await validate_request_common(client, message, file_identifier=file_unique_id)
+        if shortener_val is None:
+            return
+        if message.from_user and not await db.is_user_exist(message.from_user.id):
+            invite_link = f"https://t.me/{client.me.username}?start=start"
+            try:
+                await message.reply_text(
+                    MSG_ERROR_START_BOT.format(invite_link=invite_link),
+                    disable_web_page_preview=True,
+                    parse_mode=enums.ParseMode.MARKDOWN,
+                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_START_CHAT, url=invite_link)]]),
+                    quote=True
+                )
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await message.reply_text(
+                    MSG_ERROR_START_BOT.format(invite_link=invite_link),
+                    disable_web_page_preview=True,
+                    parse_mode=enums.ParseMode.MARKDOWN,
+                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_START_CHAT, url=invite_link)]]),
+                    quote=True
+                )
+            return
+
+        if (message.chat.type in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]
+                and not await is_admin(client, message.chat.id)):
+            await reply_user_err(message, MSG_ERROR_NOT_ADMIN)
+            return
+
+        if not message.reply_to_message or not message.reply_to_message.media:
+            await reply_user_err(
+                message,
+                MSG_ERROR_REPLY_FILE if not message.reply_to_message else MSG_ERROR_NO_FILE)
+            return
+
+        notification_msg = handler_kwargs.get('notification_msg')
+
+        parts = message.text.split()
+        num_files = 1
+        if len(parts) > 1:
+            try:
+                num_files = int(parts[1])
+                if not 1 <= num_files <= Var.MAX_BATCH_FILES:
+                    await reply_user_err(
+                        message,
+                        MSG_ERROR_NUMBER_RANGE.format(max_files=Var.MAX_BATCH_FILES))
+                    return
+            except ValueError:
+                await reply_user_err(message, MSG_ERROR_INVALID_NUMBER)
+                return
+
+        try:
+            status_msg = await message.reply_text(MSG_PROCESSING_REQUEST, quote=True)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            status_msg = await message.reply_text(MSG_PROCESSING_REQUEST, quote=True)
+        shortener_val = handler_kwargs.get('shortener', shortener_val)
+        if num_files == 1:
+            await process_single(client, message, message.reply_to_message, status_msg, shortener_val, notification_msg=notification_msg)
+        else:
+            await process_batch(client, message, message.reply_to_message.id, num_files, status_msg, shortener_val, notification_msg=notification_msg)
+
+    await handle_rate_limited_request(bot, msg, _actual_link_handler, **kwargs)
+
+
+@StreamBot.on_message(
+    filters.private &
+    filters.incoming &
+    (filters.document | filters.video | filters.photo | filters.audio |
+     filters.voice | filters.animation | filters.video_note),
+    group=4
+)
+async def private_receive_handler(bot: Client, msg: Message, **kwargs):
+    async def _actual_private_receive_handler(client: Client, message: Message, **handler_kwargs):
+        shortener_val = await validate_request_common(client, message)
+        if shortener_val is None:
+            return
+        if not message.from_user:
+            return
+
+        notification_msg = handler_kwargs.get('notification_msg')
+
+        await log_newusr(client, message.from_user.id, message.from_user.first_name or "")
+        try:
+            status_msg = await message.reply_text(MSG_PROCESSING_FILE, quote=True)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            status_msg = await message.reply_text(MSG_PROCESSING_FILE, quote=True)
+        await process_single(client, message, message, status_msg, shortener_val, notification_msg=notification_msg)
+
+    await handle_rate_limited_request(bot, msg, _actual_private_receive_handler, **kwargs)
+
+
+@StreamBot.on_message(
+    filters.channel &
+    filters.incoming &
+    (filters.document | filters.video | filters.audio) &
+    ~filters.chat(Var.BIN_CHANNEL),
+    group=-1
+)
+async def channel_receive_handler(bot: Client, msg: Message):
+    async def _actual_channel_receive_handler(client: Client, message: Message, **handler_kwargs):
+        if not Var.CHANNEL:
+            return
+        notification_msg = handler_kwargs.get('notification_msg')
+
+        is_banned_statically = hasattr(Var, 'BANNED_CHANNELS') and message.chat.id in Var.BANNED_CHANNELS
+        is_banned_dynamically = await db.is_channel_banned(message.chat.id) is not None
+
+        if is_banned_statically or is_banned_dynamically:
+            try:
+                try:
+                    await client.leave_chat(message.chat.id)
+                except FloodWait as e:
+                    await asyncio.sleep(e.value)
+                    await client.leave_chat(message.chat.id)
+            except Exception as e:
+                logger.error(f"Error leaving banned channel {message.chat.id}: {e}")
+            return
+        if not await is_admin(client, message.chat.id):
+            logger.debug(
+                f"Bot is not admin in channel {message.chat.id} "
+                f"({message.chat.title or 'Unknown'}). Ignoring message.")
+            return
+
         try:
             shortener_val = await get_shortener_status(client, message)
             canonical_record, stored_msg, reused_existing = await get_or_create_canonical_file(message, fwd_media)
@@ -369,27 +404,27 @@ async def channel_receive_handler(bot: Client, msg: Message):
 
             if notification_msg:
                 try:
-                    try:
-                        await notification_msg.edit_text(
-                            MSG_NEW_FILE_REQUEST.format(
-                                source_info=source_info,
-                                id_=message.chat.id,
-                                online_link=links['online_link'],
-                                stream_link=links['stream_link']
-                            ),
-                            disable_web_page_preview=True
-                        )
-                    except FloodWait as e:
-                        await asyncio.sleep(e.value)
-                        await notification_msg.edit_text(
-                            MSG_NEW_FILE_REQUEST.format(
-                                source_info=source_info,
-                                id_=message.chat.id,
-                                online_link=links['online_link'],
-                                stream_link=links['stream_link']
-                            ),
-                            disable_web_page_preview=True
-                        )
+                    try:
+                        await notification_msg.edit_text(
+                            MSG_NEW_FILE_REQUEST.format(
+                                source_info=source_info,
+                                id_=message.chat.id,
+                                online_link=links['online_link'],
+                                stream_link=links['stream_link']
+                            ),
+                            disable_web_page_preview=True
+                        )
+                    except FloodWait as e:
+                        await asyncio.sleep(e.value)
+                        await notification_msg.edit_text(
+                            MSG_NEW_FILE_REQUEST.format(
+                                source_info=source_info,
+                                id_=message.chat.id,
+                                online_link=links['online_link'],
+                                stream_link=links['stream_link']
+                            ),
+                            disable_web_page_preview=True
+                        )
                 except Exception as e:
                     logger.error(f"Error editing notification message with links: {e}", exc_info=True)
                     await send_channel_links(
@@ -407,43 +442,43 @@ async def channel_receive_handler(bot: Client, msg: Message):
                     target_msg=stored_msg,
                     reply_to_message_id=reply_to_message_id
                 )
-
-            try:
-                try:
-                    await message.edit_reply_markup(reply_markup=get_link_buttons(links))
-                except FloodWait as e:
-                    await asyncio.sleep(e.value)
-                    await message.edit_reply_markup(reply_markup=get_link_buttons(links))
-            except (MessageNotModified, MessageDeleteForbidden, MessageIdInvalid):
-                logger.debug(f"Failed to edit reply markup for message {message.id} due to not modified, permissions or invalid ID. Sending new link instead.")
-                await send_link(message, links)
-            except Exception as e:
-                logger.error(f"Error editing reply markup for message {message.id}: {e}", exc_info=True)
-                await send_link(message, links)
-        except Exception as e:
-            logger.error(f"Error in _actual_channel_receive_handler for message {message.id}: {e}", exc_info=True)
-
-    rl_user_id = None
-    if msg.sender_chat and msg.sender_chat.id:
-        rl_user_id = msg.sender_chat.id
-    elif msg.from_user:
-        rl_user_id = msg.from_user.id
-    
-    if rl_user_id is None:
-        logger.debug(f"No identifiable user/channel for rate limiting for message {msg.id}. Skipping rate limit check and processing directly.")
-        await _actual_channel_receive_handler(bot, msg)
-        return
-
-    await handle_rate_limited_request(bot, msg, _actual_channel_receive_handler, rl_user_id=rl_user_id)
-
-
-async def process_single(
-    bot: Client,
-    msg: Message,
-    file_msg: Message,
-    status_msg: Message,
-    shortener_val: bool,
-    original_request_msg: Optional[Message] = None,
+
+            try:
+                try:
+                    await message.edit_reply_markup(reply_markup=get_link_buttons(links))
+                except FloodWait as e:
+                    await asyncio.sleep(e.value)
+                    await message.edit_reply_markup(reply_markup=get_link_buttons(links))
+            except (MessageNotModified, MessageDeleteForbidden, MessageIdInvalid):
+                logger.debug(f"Failed to edit reply markup for message {message.id} due to not modified, permissions or invalid ID. Sending new link instead.")
+                await send_link(message, links)
+            except Exception as e:
+                logger.error(f"Error editing reply markup for message {message.id}: {e}", exc_info=True)
+                await send_link(message, links)
+        except Exception as e:
+            logger.error(f"Error in _actual_channel_receive_handler for message {message.id}: {e}", exc_info=True)
+
+    rl_user_id = None
+    if msg.sender_chat and msg.sender_chat.id:
+        rl_user_id = msg.sender_chat.id
+    elif msg.from_user:
+        rl_user_id = msg.from_user.id
+    
+    if rl_user_id is None:
+        logger.debug(f"No identifiable user/channel for rate limiting for message {msg.id}. Skipping rate limit check and processing directly.")
+        await _actual_channel_receive_handler(bot, msg)
+        return
+
+    await handle_rate_limited_request(bot, msg, _actual_channel_receive_handler, rl_user_id=rl_user_id)
+
+
+async def process_single(
+    bot: Client,
+    msg: Message,
+    file_msg: Message,
+    status_msg: Message,
+    shortener_val: bool,
+    original_request_msg: Optional[Message] = None,
     notification_msg: Optional[Message] = None
 ):
     try:
@@ -467,33 +502,33 @@ async def process_single(
                     return None
             links = await gen_links(stored_msg, shortener=shortener_val)
             canonical_reply_id = stored_msg.id
-        if notification_msg:
-            result = await safe_edit_message(
-                notification_msg,
-                MSG_LINKS.format(
-                    file_name=links['media_name'],
-                    file_size=links['media_size'],
-                    download_link=links['online_link'],
-                    stream_link=links['stream_link']
-                ),
-                parse_mode=enums.ParseMode.MARKDOWN,
-                disable_web_page_preview=True,
-                reply_markup=get_link_buttons(links)
-            )
-            if not result:
-                await send_link(msg, links)
+        if notification_msg:
+            result = await safe_edit_message(
+                notification_msg,
+                MSG_LINKS.format(
+                    file_name=links['media_name'],
+                    file_size=links['media_size'],
+                    download_link=links['online_link'],
+                    stream_link=links['stream_link']
+                ),
+                parse_mode=enums.ParseMode.MARKDOWN,
+                disable_web_page_preview=True,
+                reply_markup=get_link_buttons(links)
+            )
+            if not result:
+                await send_link(msg, links)
         elif not original_request_msg:
-            await send_link(msg, links)
-        if msg.chat.type != enums.ChatType.PRIVATE and msg.from_user and not original_request_msg:
-            await send_dm_links(bot, msg.from_user.id, links, msg.chat.title or "the chat")
-        source_msg = original_request_msg if original_request_msg else msg
-        source_info = ""
-        source_id = 0
-        if source_msg.from_user:
-            source_info = source_msg.from_user.full_name
-            if not source_info:
-                source_info = f"@{source_msg.from_user.username}" if source_msg.from_user.username else "Unknown User"
-            source_id = source_msg.from_user.id
+            await send_link(msg, links)
+        if msg.chat.type != enums.ChatType.PRIVATE and msg.from_user and not original_request_msg:
+            await send_dm_links(bot, msg.from_user.id, links, msg.chat.title or "the chat")
+        source_msg = original_request_msg if original_request_msg else msg
+        source_info = ""
+        source_id = 0
+        if source_msg.from_user:
+            source_info = source_msg.from_user.full_name
+            if not source_info:
+                source_info = f"@{source_msg.from_user.username}" if source_msg.from_user.username else "Unknown User"
+            source_id = source_msg.from_user.id
         elif source_msg.chat.type == enums.ChatType.CHANNEL:
             source_info = source_msg.chat.title or "Unknown Channel"
             source_id = source_msg.chat.id
@@ -517,152 +552,152 @@ async def process_single(
                 )
         if status_msg:
             await safe_delete_message(status_msg)
-        return links
-    except Exception as e:
-        logger.error(f"Error processing single file for message {file_msg.id}: {e}", exc_info=True)
-        if status_msg:
-            await safe_edit_message(status_msg, MSG_ERROR_PROCESSING_MEDIA)
-        
-        await notify_own(bot, MSG_CRITICAL_ERROR.format(
-            error=str(e),
-            error_id=secrets.token_hex(6)
-        ))
-        return None
-
-
-async def process_batch(
-    bot: Client,
-    msg: Message,
-    start_id: int,
-    count: int,
-    status_msg: Message,
-    shortener_val: bool,
-    notification_msg: Optional[Message] = None
-):
-    processed = 0
-    failed = 0
-    links_list = []
-    for batch_start in range(0, count, BATCH_SIZE):
-        batch_size = min(BATCH_SIZE, count - batch_start)
-        batch_ids = list(range(start_id + batch_start, start_id + batch_start + batch_size))
-        try:
-            try:
-                await status_msg.edit_text(
-                    MSG_PROCESSING_BATCH.format(
-                        batch_number=(batch_start // BATCH_SIZE) + 1,
-                        total_batches=(count + BATCH_SIZE - 1) // BATCH_SIZE,
-                        file_count=batch_size
-                    )
-                )
-            except FloodWait as e:
-                await asyncio.sleep(e.value)
-                await status_msg.edit_text(
-                    MSG_PROCESSING_BATCH.format(
-                        batch_number=(batch_start // BATCH_SIZE) + 1,
-                        total_batches=(count + BATCH_SIZE - 1) // BATCH_SIZE,
-                        file_count=batch_size
-                    )
-                )
-        except MessageNotModified:
-            pass
-        try:
-            try:
-                messages = await bot.get_messages(msg.chat.id, batch_ids)
-            except FloodWait as e:
-                await asyncio.sleep(e.value)
-                messages = await bot.get_messages(msg.chat.id, batch_ids)
-            if messages is None:
-                messages = []
-        except Exception as e:
-            logger.error(f"Error getting messages in batch: {e}", exc_info=True)
-            messages = []
-        for m in messages:
-            if m and m.media:
-                links = await process_single(bot, msg, m, None, shortener_val, original_request_msg=msg)
-                if links:
-                    links_list.append(links['online_link'])
-                    processed += 1
-                else:
-                    failed += 1
-            else:
-                failed += 1
-        if (processed + failed) % BATCH_UPDATE_INTERVAL == 0 or (processed + failed) == count:
-            try:
-                try:
-                    await status_msg.edit_text(
-                        MSG_PROCESSING_STATUS.format(
-                            processed=processed,
-                            total=count,
-                            failed=failed
-                        )
-                    )
-                except FloodWait as e:
-                    await asyncio.sleep(e.value)
-                    await status_msg.edit_text(
-                        MSG_PROCESSING_STATUS.format(
-                            processed=processed,
-                            total=count,
-                            failed=failed
-                        )
-                    )
-            except MessageNotModified:
-                pass
-    for i in range(0, len(links_list), LINK_CHUNK_SIZE):
-        chunk = links_list[i:i+LINK_CHUNK_SIZE]
-        chunk_text = MSG_BATCH_LINKS_READY.format(count=len(chunk)) + f"\n\n<code>{chr(10).join(chunk)}</code>"
-        try:
-            await msg.reply_text(
-                chunk_text,
-                quote=True,
-                disable_web_page_preview=True,
-                parse_mode=enums.ParseMode.HTML
-            )
-        except FloodWait as e:
-            await asyncio.sleep(e.value)
-            await msg.reply_text(
-                chunk_text,
-                quote=True,
-                disable_web_page_preview=True,
-                parse_mode=enums.ParseMode.HTML
-            )
-        if msg.chat.type != enums.ChatType.PRIVATE and msg.from_user:
-            try:
-                try:
-                    await bot.send_message(
-                        chat_id=msg.from_user.id,
-                        text=MSG_DM_BATCH_PREFIX.format(chat_title=msg.chat.title or "the chat") + "\n" + chunk_text,
-                        disable_web_page_preview=True,
-                        parse_mode=enums.ParseMode.HTML
-                    )
-                except FloodWait as e:
-                    await asyncio.sleep(e.value)
-                    await bot.send_message(
-                        chat_id=msg.from_user.id,
-                        text=MSG_DM_BATCH_PREFIX.format(chat_title=msg.chat.title or "the chat") + "\n" + chunk_text,
-                        disable_web_page_preview=True,
-                        parse_mode=enums.ParseMode.HTML
-                    )
-            except Exception as e:
-                logger.error(f"Error sending DM in batch: {e}", exc_info=True)
-                await reply_user_err(msg, MSG_ERROR_DM_FAILED)
-        if i + LINK_CHUNK_SIZE < len(links_list):
-            await asyncio.sleep(MESSAGE_DELAY)
-    try:
-        await status_msg.edit_text(
-            MSG_PROCESSING_RESULT.format(
-                processed=processed,
-                total=count,
-                failed=failed
-            )
-        )
-    except FloodWait as e:
-        await asyncio.sleep(e.value)
-        await status_msg.edit_text(
-            MSG_PROCESSING_RESULT.format(
-                processed=processed,
-                total=count,
-                failed=failed
-            )
-        )
-    if notification_msg:
-        await safe_delete_message(notification_msg)
+        return links
+    except Exception as e:
+        logger.error(f"Error processing single file for message {file_msg.id}: {e}", exc_info=True)
+        if status_msg:
+            await safe_edit_message(status_msg, MSG_ERROR_PROCESSING_MEDIA)
+        
+        await notify_own(bot, MSG_CRITICAL_ERROR.format(
+            error=str(e),
+            error_id=secrets.token_hex(6)
+        ))
+        return None
+
+
+async def process_batch(
+    bot: Client,
+    msg: Message,
+    start_id: int,
+    count: int,
+    status_msg: Message,
+    shortener_val: bool,
+    notification_msg: Optional[Message] = None
+):
+    processed = 0
+    failed = 0
+    links_list = []
+    for batch_start in range(0, count, BATCH_SIZE):
+        batch_size = min(BATCH_SIZE, count - batch_start)
+        batch_ids = list(range(start_id + batch_start, start_id + batch_start + batch_size))
+        try:
+            try:
+                await status_msg.edit_text(
+                    MSG_PROCESSING_BATCH.format(
+                        batch_number=(batch_start // BATCH_SIZE) + 1,
+                        total_batches=(count + BATCH_SIZE - 1) // BATCH_SIZE,
+                        file_count=batch_size
+                    )
+                )
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                await status_msg.edit_text(
+                    MSG_PROCESSING_BATCH.format(
+                        batch_number=(batch_start // BATCH_SIZE) + 1,
+                        total_batches=(count + BATCH_SIZE - 1) // BATCH_SIZE,
+                        file_count=batch_size
+                    )
+                )
+        except MessageNotModified:
+            pass
+        try:
+            try:
+                messages = await bot.get_messages(msg.chat.id, batch_ids)
+            except FloodWait as e:
+                await asyncio.sleep(e.value)
+                messages = await bot.get_messages(msg.chat.id, batch_ids)
+            if messages is None:
+                messages = []
+        except Exception as e:
+            logger.error(f"Error getting messages in batch: {e}", exc_info=True)
+            messages = []
+        for m in messages:
+            if m and m.media:
+                links = await process_single(bot, msg, m, None, shortener_val, original_request_msg=msg)
+                if links:
+                    links_list.append(links['online_link'])
+                    processed += 1
+                else:
+                    failed += 1
+            else:
+                failed += 1
+        if (processed + failed) % BATCH_UPDATE_INTERVAL == 0 or (processed + failed) == count:
+            try:
+                try:
+                    await status_msg.edit_text(
+                        MSG_PROCESSING_STATUS.format(
+                            processed=processed,
+                            total=count,
+                            failed=failed
+                        )
+                    )
+                except FloodWait as e:
+                    await asyncio.sleep(e.value)
+                    await status_msg.edit_text(
+                        MSG_PROCESSING_STATUS.format(
+                            processed=processed,
+                            total=count,
+                            failed=failed
+                        )
+                    )
+            except MessageNotModified:
+                pass
+    for i in range(0, len(links_list), LINK_CHUNK_SIZE):
+        chunk = links_list[i:i+LINK_CHUNK_SIZE]
+        chunk_text = MSG_BATCH_LINKS_READY.format(count=len(chunk)) + f"\n\n<code>{chr(10).join(chunk)}</code>"
+        try:
+            await msg.reply_text(
+                chunk_text,
+                quote=True,
+                disable_web_page_preview=True,
+                parse_mode=enums.ParseMode.HTML
+            )
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+            await msg.reply_text(
+                chunk_text,
+                quote=True,
+                disable_web_page_preview=True,
+                parse_mode=enums.ParseMode.HTML
+            )
+        if msg.chat.type != enums.ChatType.PRIVATE and msg.from_user:
+            try:
+                try:
+                    await bot.send_message(
+                        chat_id=msg.from_user.id,
+                        text=MSG_DM_BATCH_PREFIX.format(chat_title=msg.chat.title or "the chat") + "\n" + chunk_text,
+                        disable_web_page_preview=True,
+                        parse_mode=enums.ParseMode.HTML
+                    )
+                except FloodWait as e:
+                    await asyncio.sleep(e.value)
+                    await bot.send_message(
+                        chat_id=msg.from_user.id,
+                        text=MSG_DM_BATCH_PREFIX.format(chat_title=msg.chat.title or "the chat") + "\n" + chunk_text,
+                        disable_web_page_preview=True,
+                        parse_mode=enums.ParseMode.HTML
+                    )
+            except Exception as e:
+                logger.error(f"Error sending DM in batch: {e}", exc_info=True)
+                await reply_user_err(msg, MSG_ERROR_DM_FAILED)
+        if i + LINK_CHUNK_SIZE < len(links_list):
+            await asyncio.sleep(MESSAGE_DELAY)
+    try:
+        await status_msg.edit_text(
+            MSG_PROCESSING_RESULT.format(
+                processed=processed,
+                total=count,
+                failed=failed
+            )
+        )
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        await status_msg.edit_text(
+            MSG_PROCESSING_RESULT.format(
+                processed=processed,
+                total=count,
+                failed=failed
+            )
+        )
+    if notification_msg:
+        await safe_delete_message(notification_msg)

Thunder/bot/plugins/subscription.py

@@ -0,0 +1,472 @@
+# Thunder/bot/plugins/subscription.py
+
+import asyncio
+import datetime
+import urllib.parse
+from typing import Optional
+
+from pyrogram import Client, filters
+from pyrogram.errors import FloodWait, MessageNotModified
+from pyrogram.types import (CallbackQuery, InlineKeyboardButton,
+                            InlineKeyboardMarkup, Message)
+
+from Thunder.bot import StreamBot
+from Thunder.utils.database import db
+from Thunder.utils.logger import logger
+from Thunder.utils.messages import (
+    MSG_PROOF_INSTRUCTION, MSG_SUB_APPROVED_USER, MSG_SUB_PLAN_ACTIVE,
+    MSG_SUB_PLAN_FREE, MSG_SUB_REJECTED_USER, MSG_TEMP_APPROVED_USER
+)
+from Thunder.vars import Var
+
+# In-memory set of users currently prompted to submit payment proof
+awaiting_proof = set()
+
+
+def get_upi_link(user_id: int) -> str:
+    note = f"FlashFile_Sub_{user_id}"
+    params = {
+        "pa": Var.UPI_ID,
+        "pn": Var.UPI_NAME,
+        "am": str(Var.SUB_PRICE),
+        "cu": "INR",
+        "tn": note
+    }
+    return f"upi://pay?{urllib.parse.urlencode(params)}"
+
+
+def get_plan_keyboard(user_id: int, file_id: Optional[str] = None) -> InlineKeyboardMarkup:
+    upi_link = get_upi_link(user_id)
+    buttons = [
+        [
+            InlineKeyboardButton(f"💳 Pay ₹{Var.SUB_PRICE} via UPI", url=upi_link)
+        ],
+        [
+            InlineKeyboardButton("📩 Submit Payment Proof", callback_data=f"proof_{user_id}")
+        ]
+    ]
+    if file_id:
+        buttons.append([
+            InlineKeyboardButton("🎟 Request 1-Time Stream Pass", callback_data=f"req_temp_{user_id}_{file_id}")
+        ])
+    buttons.append([
+        InlineKeyboardButton("❌ Close", callback_data="close_sub")
+    ])
+    return InlineKeyboardMarkup(buttons)
+
+
+@StreamBot.on_message(filters.command(["plan", "buy", "sub"]) & filters.private)
+async def plan_command_handler(client: Client, message: Message):
+    user_id = message.from_user.id
+    user_name = message.from_user.first_name or "User"
+
+    if not Var.PAYMENT_ENABLED:
+        await message.reply_text(
+            "⚡ **Flash File Service Status**\n\n"
+            "All streaming and download links are currently **100% Free**!\n"
+            "No active subscription or payment is required.",
+            quote=True
+        )
+        return
+
+    sub = await db.get_subscription(user_id)
+    now = datetime.datetime.now(datetime.timezone.utc)
+
+    if sub and sub.get("status") == "active" and sub.get("expires_at") and sub["expires_at"] > now:
+        expires = sub["expires_at"]
+        remaining = max(1, (expires - now).days)
+        text = MSG_SUB_PLAN_ACTIVE.format(
+            user_name=user_name,
+            user_id=user_id,
+            expiry_date=expires.strftime("%Y-%m-%d %H:%M UTC"),
+            remaining_days=remaining
+        )
+        keyboard = InlineKeyboardMarkup([
+            [InlineKeyboardButton("➕ Extend Subscription (₹10)", callback_data=f"sub_pay_{user_id}")],
+            [InlineKeyboardButton("❌ Close", callback_data="close_sub")]
+        ])
+    else:
+        text = MSG_SUB_PLAN_FREE.format(
+            price=Var.SUB_PRICE,
+            upi_id=Var.UPI_ID
+        )
+        keyboard = get_plan_keyboard(user_id)
+
+    await message.reply_text(text, reply_markup=keyboard, quote=True)
+
+
+@StreamBot.on_message(filters.command("addsub") & filters.private)
+async def addsub_command_handler(client: Client, message: Message):
+    sender_id = message.from_user.id
+    is_owner = sender_id == Var.OWNER_ID
+    is_admin = hasattr(Var, "ADMINS") and sender_id in Var.ADMINS
+
+    if not (is_owner or is_admin):
+        return
+
+    parts = message.text.strip().split()
+    if len(parts) < 2:
+        await message.reply_text("Usage: `/addsub <user_id> [days]`", quote=True)
+        return
+
+    try:
+        target_id = int(parts[1])
+        days = int(parts[2]) if len(parts) > 2 else Var.SUB_DURATION_DAYS
+    except ValueError:
+        await message.reply_text("Invalid user ID or days number.", quote=True)
+        return
+
+    doc = await db.add_subscription(target_id, days=days, plan="admin_granted")
+    expiry = doc["expires_at"].strftime("%Y-%m-%d %H:%M UTC")
+
+    await message.reply_text(
+        f"✅ Subscription granted to `{target_id}` for {days} days.\n"
+        f"Valid until: `{expiry}`",
+        quote=True
+    )
+
+    try:
+        await client.send_message(
+            target_id,
+            MSG_SUB_APPROVED_USER.format(expiry_date=expiry)
+        )
+    except Exception as e:
+        logger.warning(f"Could not notify user {target_id} of granted subscription: {e}")
+
+
+@StreamBot.on_message(filters.command("remsub") & filters.private)
+async def remsub_command_handler(client: Client, message: Message):
+    sender_id = message.from_user.id
+    is_owner = sender_id == Var.OWNER_ID
+    is_admin = hasattr(Var, "ADMINS") and sender_id in Var.ADMINS
+
+    if not (is_owner or is_admin):
+        return
+
+    parts = message.text.strip().split()
+    if len(parts) < 2:
+        await message.reply_text("Usage: `/remsub <user_id>`", quote=True)
+        return
+
+    try:
+        target_id = int(parts[1])
+    except ValueError:
+        await message.reply_text("Invalid user ID.", quote=True)
+        return
+
+    success = await db.remove_subscription(target_id)
+    if success:
+        await message.reply_text(f"✅ Subscription revoked for `{target_id}`.", quote=True)
+    else:
+        await message.reply_text(f"Could not revoke or no active subscription found for `{target_id}`.", quote=True)
+
+
+@StreamBot.on_message(filters.command("subscribers") & filters.private)
+async def subscribers_command_handler(client: Client, message: Message):
+    sender_id = message.from_user.id
+    is_owner = sender_id == Var.OWNER_ID
+    is_admin = hasattr(Var, "ADMINS") and sender_id in Var.ADMINS
+
+    if not (is_owner or is_admin):
+        return
+
+    count = await db.get_active_subscribers_count()
+    subscribers = await db.get_all_subscribers(limit=25)
+
+    text = f"👑 **Active Subscribers:** `{count}`\n\n"
+    if subscribers:
+        for idx, sub in enumerate(subscribers, 1):
+            exp = sub["expires_at"].strftime("%Y-%m-%d")
+            text += f"{idx}. `{sub['user_id']}` — Expiry: `{exp}` ({sub.get('plan', 'monthly')})\n"
+    else:
+        text += "No active subscribers found."
+
+    await message.reply_text(text, quote=True)
+
+
+@StreamBot.on_callback_query(filters.regex(r"^close_sub$"))
+async def close_sub_callback(client: Client, query: CallbackQuery):
+    await query.answer()
+    try:
+        await query.message.delete()
+    except Exception:
+        pass
+
+
+@StreamBot.on_callback_query(filters.regex(r"^sub_pay_(\d+)$"))
+async def sub_pay_callback(client: Client, query: CallbackQuery):
+    user_id = int(query.matches[0].group(1))
+    upi_link = get_upi_link(user_id)
+    text = (
+        "💳 **Pay ₹10 via UPI**\n\n"
+        f"**UPI ID:** `{Var.UPI_ID}`\n"
+        f"**Name:** `{Var.UPI_NAME}`\n"
+        f"**Amount:** `₹{Var.SUB_PRICE}`\n\n"
+        "Click the button below to launch Google Pay / PhonePe / Paytm / BHIM directly:"
+    )
+    keyboard = InlineKeyboardMarkup([
+        [InlineKeyboardButton(f"🚀 Open UPI App (₹{Var.SUB_PRICE})", url=upi_link)],
+        [InlineKeyboardButton("📩 Submit Proof / Tx ID", callback_data=f"proof_{user_id}")],
+        [InlineKeyboardButton("⬅️ Back", callback_data=f"plan_info_{user_id}")]
+    ])
+    await query.answer()
+    try:
+        await query.message.edit_text(text, reply_markup=keyboard)
+    except MessageNotModified:
+        pass
+
+
+@StreamBot.on_callback_query(filters.regex(r"^plan_info_(\d+)$"))
+async def plan_info_callback(client: Client, query: CallbackQuery):
+    user_id = int(query.matches[0].group(1))
+    text = MSG_SUB_PLAN_FREE.format(price=Var.SUB_PRICE, upi_id=Var.UPI_ID)
+    keyboard = get_plan_keyboard(user_id)
+    await query.answer()
+    try:
+        await query.message.edit_text(text, reply_markup=keyboard)
+    except MessageNotModified:
+        pass
+
+
+@StreamBot.on_callback_query(filters.regex(r"^proof_(\d+)$"))
+async def proof_callback(client: Client, query: CallbackQuery):
+    user_id = int(query.matches[0].group(1))
+    awaiting_proof.add(user_id)
+    await query.answer("Please send your payment screenshot or UTR number.", show_alert=True)
+    await query.message.reply_text(MSG_PROOF_INSTRUCTION, quote=True)
+
+
+@StreamBot.on_callback_query(filters.regex(r"^req_temp_(\d+)_(.+)$"))
+async def req_temp_callback(client: Client, query: CallbackQuery):
+    user_id = int(query.matches[0].group(1))
+    file_id = query.matches[0].group(2)
+    user_name = query.from_user.first_name or "User"
+
+    await query.answer("Submitting temporary stream pass request to admin...", show_alert=False)
+
+    req_id = await db.create_sub_request(
+        user_id=user_id,
+        user_name=user_name,
+        req_type="temp_pass",
+        file_id=file_id
+    )
+
+    admin_target = Var.ADMIN_CHANNEL or Var.OWNER_ID
+    if admin_target:
+        admin_card = (
+            "🎟 **New 1-Time Stream Pass Request**\n\n"
+            f"👤 **User:** {user_name} (`{user_id}`)\n"
+            f"📄 **File Unique ID:** `{file_id}`\n"
+            f"🆔 **Request ID:** `{req_id}`\n\n"
+            "Choose action below:"
+        )
+        keyboard = InlineKeyboardMarkup([
+            [
+                InlineKeyboardButton("🎟 Approve Temp Pass (24h)", callback_data=f"approve_temp_{req_id}"),
+                InlineKeyboardButton("👑 Approve 30-Day Sub", callback_data=f"approve_sub_{req_id}")
+            ],
+            [
+                InlineKeyboardButton("❌ Reject", callback_data=f"reject_sub_{req_id}")
+            ]
+        ])
+        try:
+            await client.send_message(admin_target, admin_card, reply_markup=keyboard)
+        except Exception as e:
+            logger.error(f"Failed to notify admin target {admin_target} of temp pass request: {e}")
+
+    await query.message.reply_text(
+        "⏳ **Request Submitted!**\n\n"
+        "Your temporary pass request has been sent to the admin team for approval. "
+        "You will receive a notification as soon as it is reviewed.",
+        quote=True
+    )
+
+
+@StreamBot.on_callback_query(filters.regex(r"^approve_sub_([a-f0-9]+)$"))
+async def approve_sub_callback(client: Client, query: CallbackQuery):
+    admin_id = query.from_user.id
+    if not (admin_id == Var.OWNER_ID or (hasattr(Var, "ADMINS") and admin_id in Var.ADMINS)):
+        await query.answer("Unauthorized", show_alert=True)
+        return
+
+    req_id = query.matches[0].group(1)
+    req = await db.get_sub_request(req_id)
+    if not req or req.get("status") != "pending":
+        await query.answer("This request has already been processed.", show_alert=True)
+        return
+
+    user_id = req["user_id"]
+    doc = await db.add_subscription(user_id, days=Var.SUB_DURATION_DAYS, tx_ref=req.get("tx_ref", ""))
+    await db.update_sub_request_status(req_id, "approved_sub", admin_id)
+
+    admin_name = query.from_user.first_name or "Admin"
+    expiry = doc["expires_at"].strftime("%Y-%m-%d %H:%M UTC")
+
+    await query.answer("30-Day Monthly Subscription Approved!", show_alert=True)
+    try:
+        await query.message.edit_text(
+            f"{query.message.text}\n\n"
+            f"✅ **APPROVED (30-Day Plan)** by {admin_name} on {datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%d %H:%M')}"
+        )
+    except MessageNotModified:
+        pass
+
+    try:
+        await client.send_message(
+            user_id,
+            MSG_SUB_APPROVED_USER.format(expiry_date=expiry)
+        )
+    except Exception as e:
+        logger.warning(f"Could not notify user {user_id} of approved subscription: {e}")
+
+
+@StreamBot.on_callback_query(filters.regex(r"^approve_temp_([a-f0-9]+)$"))
+async def approve_temp_callback(client: Client, query: CallbackQuery):
+    admin_id = query.from_user.id
+    if not (admin_id == Var.OWNER_ID or (hasattr(Var, "ADMINS") and admin_id in Var.ADMINS)):
+        await query.answer("Unauthorized", show_alert=True)
+        return
+
+    req_id = query.matches[0].group(1)
+    req = await db.get_sub_request(req_id)
+    if not req or req.get("status") != "pending":
+        await query.answer("This request has already been processed.", show_alert=True)
+        return
+
+    user_id = req["user_id"]
+    file_id = req.get("file_id") or "any"
+    await db.add_temp_pass(user_id, file_id, hours=24)
+    await db.update_sub_request_status(req_id, "approved_temp", admin_id)
+
+    admin_name = query.from_user.first_name or "Admin"
+
+    await query.answer("1-Time Temporary Stream Pass Approved!", show_alert=True)
+    try:
+        await query.message.edit_text(
+            f"{query.message.text}\n\n"
+            f"🎟 **APPROVED (1-Time Pass)** by {admin_name} on {datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%d %H:%M')}"
+        )
+    except MessageNotModified:
+        pass
+
+    try:
+        await client.send_message(
+            user_id,
+            MSG_TEMP_APPROVED_USER
+        )
+    except Exception as e:
+        logger.warning(f"Could not notify user {user_id} of approved temp pass: {e}")
+
+
+@StreamBot.on_callback_query(filters.regex(r"^reject_sub_([a-f0-9]+)$"))
+async def reject_sub_callback(client: Client, query: CallbackQuery):
+    admin_id = query.from_user.id
+    if not (admin_id == Var.OWNER_ID or (hasattr(Var, "ADMINS") and admin_id in Var.ADMINS)):
+        await query.answer("Unauthorized", show_alert=True)
+        return
+
+    req_id = query.matches[0].group(1)
+    req = await db.get_sub_request(req_id)
+    if not req or req.get("status") != "pending":
+        await query.answer("This request has already been processed.", show_alert=True)
+        return
+
+    user_id = req["user_id"]
+    await db.update_sub_request_status(req_id, "rejected", admin_id)
+
+    admin_name = query.from_user.first_name or "Admin"
+    await query.answer("Request Rejected.", show_alert=True)
+    try:
+        await query.message.edit_text(
+            f"{query.message.text}\n\n"
+            f"❌ **REJECTED** by {admin_name} on {datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%d %H:%M')}"
+        )
+    except MessageNotModified:
+        pass
+
+    try:
+        await client.send_message(
+            user_id,
+            MSG_SUB_REJECTED_USER
+        )
+    except Exception as e:
+        logger.warning(f"Could not notify user {user_id} of rejected request: {e}")
+
+
+@StreamBot.on_message(filters.private & (filters.photo | filters.document | filters.text) & ~filters.command(["start", "help", "about", "plan", "buy", "sub"]))
+async def proof_receiver_handler(client: Client, message: Message):
+    user_id = message.from_user.id if message.from_user else None
+    if not user_id:
+        return
+
+    # Check if user is actively awaiting proof or if message looks like a payment proof
+    has_text_utr = False
+    tx_ref = ""
+    if message.text:
+        text = message.text.strip()
+        # Common UTR / UPI transaction references (12 digits or words like UPI, UTR, ref)
+        if len(text) >= 8 and (text.isdigit() or any(k in text.lower() for k in ["utr", "upi", "txn", "ref", "paid"])):
+            has_text_utr = True
+            tx_ref = text
+
+    is_photo_proof = bool(message.photo or (message.document and message.document.mime_type and "image" in message.document.mime_type))
+
+    if user_id not in awaiting_proof and not (has_text_utr and len(tx_ref) == 12 and tx_ref.isdigit()):
+        return
+
+    awaiting_proof.discard(user_id)
+    user_name = message.from_user.first_name or "User"
+
+    photo_file_id = message.photo.file_id if message.photo else (message.document.file_id if message.document else None)
+    caption_text = message.caption or tx_ref or "Payment Proof attached"
+
+    req_id = await db.create_sub_request(
+        user_id=user_id,
+        user_name=user_name,
+        req_type="monthly_proof",
+        tx_ref=caption_text,
+        proof_file_id=photo_file_id
+    )
+
+    admin_target = Var.ADMIN_CHANNEL or Var.OWNER_ID
+    if admin_target:
+        card_text = (
+            "💰 **New Payment Proof Received**\n\n"
+            f"👤 **User:** {user_name} (`{user_id}`)\n"
+            f"📝 **Ref / Note:** `{caption_text}`\n"
+            f"🆔 **Request ID:** `{req_id}`\n\n"
+            "Review payment and choose action:"
+        )
+        keyboard = InlineKeyboardMarkup([
+            [
+                InlineKeyboardButton("✅ Approve 30-Day Sub", callback_data=f"approve_sub_{req_id}"),
+                InlineKeyboardButton("🎟 Approve Temp Pass", callback_data=f"approve_temp_{req_id}")
+            ],
+            [
+                InlineKeyboardButton("❌ Reject", callback_data=f"reject_sub_{req_id}")
+            ]
+        ])
+
+        try:
+            if photo_file_id:
+                await client.send_photo(
+                    admin_target,
+                    photo=photo_file_id,
+                    caption=card_text,
+                    reply_markup=keyboard
+                )
+            else:
+                await client.send_message(
+                    admin_target,
+                    card_text,
+                    reply_markup=keyboard
+                )
+        except Exception as e:
+            logger.error(f"Failed to forward proof to admin {admin_target}: {e}")
+
+    await message.reply_text(
+        "✅ **Payment Proof Received!**\n\n"
+        "Your transaction has been submitted to admin for verification.\n"
+        "Your pass will be activated as soon as it is confirmed.",
+        quote=True
+    )

Thunder/utils/commands.py

@@ -1,38 +1,43 @@
-from pyrogram.types import BotCommand
-
-from Thunder.bot import StreamBot
-from Thunder.utils.logger import logger
-from Thunder.vars import Var
-
-def get_commands():
-    command_descriptions = {
-        "start": "Start the bot and get a welcome message",
-        "link": "(Group) Generate a direct link for a file or batch",
-        "dc": "Retrieve the data center (DC) information of a user or file",
-        "ping": "Check the bot's status and response time",
-        "about": "Get information about the bot",
-        "help": "Show help and usage instructions",
-        "status": "(Admin) View bot details and current workload",
-        "stats": "(Admin) View usage statistics and resource consumption",
-        "broadcast": "(Admin) Send a message to all users",
-        "ban": "(Admin) Ban a user",
-        "unban": "(Admin) Unban a user",
-        "log": "(Admin) Send bot logs",
-        "restart": "(Admin) Update and restart the bot",
-        "shell": "(Admin) Execute a shell command",
-        "speedtest": "(Admin) Run network speed test",
-        "users": "(Admin) Show the total number of users",
-        "authorize": "(Admin) Grant permanent access to a user",
-        "deauthorize": "(Admin) Remove permanent access from a user",
-        "listauth": "(Admin) List all authorized users"
-    }
-    return [BotCommand(name, desc) for name, desc in command_descriptions.items()]
-
-async def set_commands():
-    if Var.SET_COMMANDS:
-        try:
-            commands = get_commands()
-            if commands:
-                await StreamBot.set_bot_commands(commands)
-        except Exception as e:
-            logger.error(f"Failed to set bot commands: {e}", exc_info=True)
+from pyrogram.types import BotCommand
+
+from Thunder.bot import StreamBot
+from Thunder.utils.logger import logger
+from Thunder.vars import Var
+
+def get_commands():
+    command_descriptions = {
+        "start": "Start the bot and get a welcome message",
+        "link": "(Group) Generate a direct link for a file or batch",
+        "dc": "Retrieve the data center (DC) information of a user or file",
+        "ping": "Check the bot's status and response time",
+        "about": "Get information about the bot",
+        "help": "Show help and usage instructions",
+        "status": "(Admin) View bot details and current workload",
+        "stats": "(Admin) View usage statistics and resource consumption",
+        "broadcast": "(Admin) Send a message to all users",
+        "ban": "(Admin) Ban a user",
+        "unban": "(Admin) Unban a user",
+        "log": "(Admin) Send bot logs",
+        "restart": "(Admin) Update and restart the bot",
+        "shell": "(Admin) Execute a shell command",
+        "speedtest": "(Admin) Run network speed test",
+        "users": "(Admin) Show the total number of users",
+        "authorize": "(Admin) Grant permanent access to a user",
+        "deauthorize": "(Admin) Remove permanent access from a user",
+                "listauth": "(Admin) List all authorized users",
+        "plan": "View subscription status or purchase monthly plan",
+        "buy": "Purchase ₹10/month subscription pass",
+        "addsub": "(Admin) Grant subscription to a user",
+        "remsub": "(Admin) Revoke subscription from a user",
+        "subscribers": "(Admin) View active subscriber count"
+    }
+    return [BotCommand(name, desc) for name, desc in command_descriptions.items()]
+
+async def set_commands():
+    if Var.SET_COMMANDS:
+        try:
+            commands = get_commands()
+            if commands:
+                await StreamBot.set_bot_commands(commands)
+        except Exception as e:
+            logger.error(f"Failed to set bot commands: {e}", exc_info=True)

Thunder/utils/database.py

@@ -1,453 +1,625 @@
-# Thunder/utils/database.py
-
-import datetime
-from typing import Any, Dict, Optional
-from pymongo import AsyncMongoClient
-from pymongo.asynchronous.collection import AsyncCollection
-from pymongo.errors import DuplicateKeyError
-from Thunder.vars import Var
-from Thunder.utils.logger import logger
-
-class Database:
-    def __init__(self, uri: str, database_name: str, *args, **kwargs):
-        self._client = AsyncMongoClient(uri, *args, **kwargs)
-        self.db = self._client[database_name]
-        self.col: AsyncCollection = self.db.users
-        self.banned_users_col: AsyncCollection = self.db.banned_users
-        self.banned_channels_col: AsyncCollection = self.db.banned_channels
-        self.token_col: AsyncCollection = self.db.tokens
-        self.authorized_users_col: AsyncCollection = self.db.authorized_users
-        self.restart_message_col: AsyncCollection = self.db.restart_message
-        self.files_col: AsyncCollection = self.db.files
-        self.file_ingest_locks_col: AsyncCollection = self.db.file_ingest_locks
-
-    async def _deduplicate_users(self) -> None:
-        pipeline = [
-            {"$sort": {"join_date": 1}},
-            {"$group": {"_id": "$id", "doc_id": {"$first": "$_id"}}},
-            {"$project": {"_id": "$doc_id"}}
-        ]
-        keep_ids = []
-        async for doc in self.col.aggregate(pipeline):
-            keep_ids.append(doc["_id"])
-        if keep_ids:
-            result = await self.col.delete_many({"_id": {"$nin": keep_ids}})
-            if result.deleted_count > 0:
-                logger.warning(f"Deduplicated {result.deleted_count} duplicate user documents.")
-
-    async def ensure_indexes(self, *, raise_on_error: bool = True) -> bool:
-        try:
-            await self.banned_users_col.create_index("user_id", unique=True)
-            await self.banned_channels_col.create_index("channel_id", unique=True)
-            await self.token_col.create_index("token", unique=True)
-            await self.authorized_users_col.create_index("user_id", unique=True)
-            try:
-                await self.col.create_index("id", unique=True)
-            except DuplicateKeyError:
-                logger.warning("Duplicate users found, deduplicating...")
-                await self._deduplicate_users()
-                await self.col.create_index("id", unique=True)
-            await self.token_col.create_index("expires_at", expireAfterSeconds=0)
-            await self.token_col.create_index("activated")
-            await self.restart_message_col.create_index("message_id", unique=True)
-            await self.restart_message_col.create_index("timestamp", expireAfterSeconds=3600)
-            await self.files_col.create_index("file_unique_id", unique=True)
-            await self.files_col.create_index("public_hash", unique=True)
-            await self.files_col.create_index("canonical_message_id", unique=True)
-            await self.files_col.create_index("created_at")
-            await self.files_col.create_index("last_seen_at")
-            await self.file_ingest_locks_col.create_index("expires_at", expireAfterSeconds=0)
-
-            logger.debug("Database indexes ensured.")
-            return True
-        except Exception as e:
-            logger.error(f"Error in ensure_indexes: {e}", exc_info=True)
-            if raise_on_error:
-                raise
-            return False
-
-    def new_user(self, user_id: int) -> dict:
-        try:
-            return {
-                'id': user_id,
-                'join_date': datetime.datetime.now(datetime.timezone.utc)
-            }
-        except Exception as e:
-            logger.error(f"Error in new_user for user {user_id}: {e}", exc_info=True)
-            raise
-
-    async def add_user(self, user_id: int) -> bool:
-        try:
-            result = await self.col.update_one(
-                {'id': user_id},
-                {'$setOnInsert': self.new_user(user_id)},
-                upsert=True
-            )
-            if result.upserted_id:
-                logger.debug(f"Added new user {user_id} to database.")
-                return True
-            return False
-        except Exception as e:
-            logger.error(f"Error in add_user for user {user_id}: {e}", exc_info=True)
-            raise
-
-
-    async def is_user_exist(self, user_id: int) -> bool:
-        """Read-only existence check. For user registration, use add_user() instead."""
-        try:
-            user = await self.col.find_one({'id': user_id}, {'_id': 1})
-            return bool(user)
-        except Exception as e:
-            logger.error(f"Error in is_user_exist for user {user_id}: {e}", exc_info=True)
-            raise
-
-    async def total_users_count(self) -> int:
-        try:
-            return await self.col.count_documents({})
-        except Exception as e:
-            logger.error(f"Error in total_users_count: {e}", exc_info=True)
-            return 0
-
-    async def get_authorized_users_count(self) -> int:
-        try:
-            return await self.authorized_users_col.count_documents({})
-        except Exception as e:
-            logger.error(f"Error in get_authorized_users_count: {e}", exc_info=True)
-            return 0
-
-    async def get_regular_users_count(self) -> int:
-        try:
-            auth_ids = await self.authorized_users_col.distinct("user_id")
-            return await self.col.count_documents({"id": {"$nin": auth_ids}})
-        except Exception as e:
-            logger.error(f"Error in get_regular_users_count: {e}", exc_info=True)
-            return 0
-
-    async def get_all_users(self):
-        try:
-            return self.col.find({})
-        except Exception as e:
-            logger.error(f"Error in get_all_users: {e}", exc_info=True)
-            return self.col.find({"_id": {"$exists": False}})
-
-    async def get_authorized_users_cursor(self):
-        try:
-            return self.authorized_users_col.find({})
-        except Exception as e:
-            logger.error(f"Error in get_authorized_users_cursor: {e}", exc_info=True)
-            return self.authorized_users_col.find({"_id": {"$exists": False}})
-
-    async def get_regular_users_cursor(self):
-        try:
-            auth_ids = await self.authorized_users_col.distinct("user_id")
-            return self.col.find({"id": {"$nin": auth_ids}})
-        except Exception as e:
-            logger.error(f"Error in get_regular_users_cursor: {e}", exc_info=True)
-            return self.col.find({"_id": {"$exists": False}})
-
-    async def delete_user(self, user_id: int):
-        try:
-            await self.col.delete_one({'id': user_id})
-            logger.debug(f"Deleted user {user_id}.")
-        except Exception as e:
-            logger.error(f"Error in delete_user for user {user_id}: {e}", exc_info=True)
-            raise
-
-
-    async def add_banned_user(
-        self, user_id: int, banned_by: Optional[int] = None,
-        reason: Optional[str] = None
-    ):
-        try:
-            ban_data = {
-                "user_id": user_id,
-                "banned_at": datetime.datetime.now(datetime.timezone.utc),
-                "banned_by": banned_by,
-                "reason": reason
-            }
-            await self.banned_users_col.update_one(
-                {"user_id": user_id},
-                {"$set": ban_data},
-                upsert=True
-            )
-            logger.debug(f"Added/Updated banned user {user_id}. Reason: {reason}")
-        except Exception as e:
-            logger.error(f"Error in add_banned_user for user {user_id}: {e}", exc_info=True)
-            raise
-
-    async def remove_banned_user(self, user_id: int) -> bool:
-        try:
-            result = await self.banned_users_col.delete_one({"user_id": user_id})
-            if result.deleted_count > 0:
-                logger.debug(f"Removed banned user {user_id}.")
-                return True
-            return False
-        except Exception as e:
-            logger.error(f"Error in remove_banned_user for user {user_id}: {e}", exc_info=True)
-            return False
-
-    async def is_user_banned(self, user_id: int) -> Optional[Dict[str, Any]]:
-        try:
-            return await self.banned_users_col.find_one({"user_id": user_id})
-        except Exception as e:
-            logger.error(f"Error in is_user_banned for user {user_id}: {e}", exc_info=True)
-            return None
-
-    async def add_banned_channel(
-        self, channel_id: int, banned_by: Optional[int] = None,
-        reason: Optional[str] = None
-    ):
-        try:
-            ban_data = {
-                "channel_id": channel_id,
-                "banned_at": datetime.datetime.now(datetime.timezone.utc),
-                "banned_by": banned_by,
-                "reason": reason
-            }
-            await self.banned_channels_col.update_one(
-                {"channel_id": channel_id},
-                {"$set": ban_data},
-                upsert=True
-            )
-            logger.debug(f"Added/Updated banned channel {channel_id}. Reason: {reason}")
-        except Exception as e:
-            logger.error(f"Error in add_banned_channel for channel {channel_id}: {e}", exc_info=True)
-            raise
-
-    async def remove_banned_channel(self, channel_id: int) -> bool:
-        try:
-            result = await self.banned_channels_col.delete_one({"channel_id": channel_id})
-            if result.deleted_count > 0:
-                logger.debug(f"Removed banned channel {channel_id}.")
-                return True
-            return False
-        except Exception as e:
-            logger.error(f"Error in remove_banned_channel for channel {channel_id}: {e}", exc_info=True)
-            return False
-
-    async def is_channel_banned(self, channel_id: int) -> Optional[Dict[str, Any]]:
-        try:
-            return await self.banned_channels_col.find_one({"channel_id": channel_id})
-        except Exception as e:
-            logger.error(f"Error in is_channel_banned for channel {channel_id}: {e}", exc_info=True)
-            return None
-
-    async def save_main_token(self, user_id: int, token_value: str, expires_at: datetime.datetime, created_at: datetime.datetime, activated: bool) -> None:
-        try:
-            await self.token_col.update_one(
-                {"user_id": user_id, "token": token_value},
-                {"$set": {
-                    "expires_at": expires_at,
-                    "created_at": created_at,
-                    "activated": activated
-                    }
-                },
-                upsert=True
-            )
-            logger.debug(f"Saved main token {token_value} for user {user_id} with activated status {activated}.")
-        except Exception as e:
-            logger.error(f"Error saving main token for user {user_id}: {e}", exc_info=True)
-            raise
-
-
-    async def add_restart_message(self, message_id: int, chat_id: int) -> None:
-        try:
-            await self.restart_message_col.insert_one({
-                "message_id": message_id,
-                "chat_id": chat_id,
-                "timestamp": datetime.datetime.now(datetime.timezone.utc)
-            })
-            logger.debug(f"Added restart message {message_id} for chat {chat_id}.")
-        except Exception as e:
-            logger.error(f"Error adding restart message {message_id}: {e}", exc_info=True)
-
-    async def get_restart_message(self) -> Optional[Dict[str, Any]]:
-        try:
-            return await self.restart_message_col.find_one(sort=[("timestamp", -1)])
-        except Exception as e:
-            logger.error(f"Error getting restart message: {e}", exc_info=True)
-            return None
-
-    async def delete_restart_message(self, message_id: int) -> None:
-        try:
-            await self.restart_message_col.delete_one({"message_id": message_id})
-            logger.debug(f"Deleted restart message {message_id}.")
-        except Exception as e:
-            logger.error(f"Error deleting restart message {message_id}: {e}", exc_info=True)
-
-    async def is_user_authorized(self, user_id: int) -> bool:
-        try:
-            user = await self.authorized_users_col.find_one({'user_id': user_id}, {'_id': 1})
-            return bool(user)
-        except Exception as e:
-            logger.error(f"Error in is_user_authorized for user {user_id}: {e}", exc_info=True)
-            return False
-
-    async def get_file_by_unique_id(self, file_unique_id: str) -> Optional[Dict[str, Any]]:
-        try:
-            return await self.files_col.find_one({"file_unique_id": file_unique_id})
-        except Exception as e:
-            logger.error(f"Error getting file by unique_id {file_unique_id}: {e}", exc_info=True)
-            return None
-
-    async def get_file_by_hash(
-        self,
-        public_hash: str,
-        *,
-        raise_on_error: bool = True
-    ) -> Optional[Dict[str, Any]]:
-        try:
-            return await self.files_col.find_one({"public_hash": public_hash})
-        except Exception as e:
-            logger.error(f"Error getting file by hash {public_hash}: {e}", exc_info=True)
-            if raise_on_error:
-                raise
-            return None
-
-    async def get_file_by_message_id(self, canonical_message_id: int) -> Optional[Dict[str, Any]]:
-        try:
-            return await self.files_col.find_one({"canonical_message_id": canonical_message_id})
-        except Exception as e:
-            logger.error(
-                f"Error getting file by message_id {canonical_message_id}: {e}",
-                exc_info=True
-            )
-            return None
-
-    async def create_file_record(self, file_record: Dict[str, Any]) -> None:
-        try:
-            await self.files_col.insert_one(file_record)
-        except Exception as e:
-            logger.error(
-                f"Error creating canonical file record for {file_record.get('file_unique_id')}: {e}",
-                exc_info=True
-            )
-            raise
-
-    async def replace_file_record(self, file_record: Dict[str, Any]) -> None:
-        try:
-            await self.files_col.replace_one(
-                {"file_unique_id": file_record["file_unique_id"]},
-                file_record,
-                upsert=True
-            )
-        except Exception as e:
-            logger.error(
-                f"Error replacing canonical file record for {file_record.get('file_unique_id')}: {e}",
-                exc_info=True
-            )
-            raise
-
-    async def touch_file_record(
-        self,
-        public_hash: str,
-        *,
-        reused: bool = False,
-        raise_on_error: bool = False
-    ) -> bool:
-        try:
-            update_doc: Dict[str, Any] = {
-                "$set": {"last_seen_at": datetime.datetime.now(datetime.timezone.utc)},
-                "$inc": {"seen_count": 1}
-            }
-            if reused:
-                update_doc["$inc"]["reuse_count"] = 1
-            await self.files_col.update_one({"public_hash": public_hash}, update_doc)
-            return True
-        except Exception as e:
-            logger.error(f"Error touching canonical file {public_hash}: {e}", exc_info=True)
-            if raise_on_error:
-                raise
-            return False
-
-    async def update_file_id(
-        self,
-        public_hash: str,
-        file_id: str,
-        *,
-        raise_on_error: bool = False
-    ) -> bool:
-        try:
-            await self.files_col.update_one(
-                {"public_hash": public_hash},
-                {
-                    "$set": {
-                        "file_id": file_id,
-                        "last_seen_at": datetime.datetime.now(datetime.timezone.utc)
-                    }
-                }
-            )
-            return True
-        except Exception as e:
-            logger.error(f"Error updating file_id for {public_hash}: {e}", exc_info=True)
-            if raise_on_error:
-                raise
-            return False
-
-    async def acquire_file_ingest_claim(
-        self,
-        file_unique_id: str,
-        *,
-        ttl_seconds: int = 60
-    ) -> bool:
-        now = datetime.datetime.now(datetime.timezone.utc)
-        claim_fields = {
-            "created_at": now,
-            "expires_at": now + datetime.timedelta(seconds=ttl_seconds)
-        }
-        try:
-            await self.file_ingest_locks_col.insert_one({
-                "_id": file_unique_id,
-                **claim_fields
-            })
-            return True
-        except DuplicateKeyError:
-            try:
-                result = await self.file_ingest_locks_col.find_one_and_update(
-                    {
-                        "_id": file_unique_id,
-                        "$or": [
-                            {"expires_at": {"$lte": now}},
-                            {"expires_at": {"$exists": False}}
-                        ]
-                    },
-                    {
-                        "$set": claim_fields
-                    },
-                    return_document=False
-                )
-                return bool(result)
-            except Exception as e:
-                logger.error(f"Error updating ingest claim for {file_unique_id}: {e}", exc_info=True)
-                raise
-        except Exception as e:
-            logger.error(f"Error acquiring ingest claim for {file_unique_id}: {e}", exc_info=True)
-            raise
-
-    async def release_file_ingest_claim(self, file_unique_id: str) -> bool:
-        try:
-            await self.file_ingest_locks_col.delete_one({"_id": file_unique_id})
-            return True
-        except Exception as e:
-            logger.error(f"Error releasing ingest claim for {file_unique_id}: {e}", exc_info=True)
-            return False
-
-    async def is_file_ingest_claim_active(self, file_unique_id: str) -> bool:
-        try:
-            claim = await self.file_ingest_locks_col.find_one(
-                {
-                    "_id": file_unique_id,
-                    "expires_at": {"$gt": datetime.datetime.now(datetime.timezone.utc)}
-                },
-                {"_id": 1}
-            )
-            return bool(claim)
-        except Exception as e:
-            logger.error(f"Error checking ingest claim for {file_unique_id}: {e}", exc_info=True)
-            raise
-
-    async def close(self):
-        if self._client:
-            await self._client.close()
-
-db = Database(Var.DATABASE_URL, Var.NAME)
+import secrets
+# Thunder/utils/database.py
+
+import datetime
+from typing import Any, Dict, Optional
+from pymongo import AsyncMongoClient
+from pymongo.asynchronous.collection import AsyncCollection
+from pymongo.errors import DuplicateKeyError
+from Thunder.vars import Var
+from Thunder.utils.logger import logger
+
+class Database:
+    def __init__(self, uri: str, database_name: str, *args, **kwargs):
+        self._client = AsyncMongoClient(uri, *args, **kwargs)
+        self.db = self._client[database_name]
+        self.col: AsyncCollection = self.db.users
+        self.banned_users_col: AsyncCollection = self.db.banned_users
+        self.banned_channels_col: AsyncCollection = self.db.banned_channels
+        self.token_col: AsyncCollection = self.db.tokens
+        self.authorized_users_col: AsyncCollection = self.db.authorized_users
+        self.restart_message_col: AsyncCollection = self.db.restart_message
+        self.files_col: AsyncCollection = self.db.files
+        self.file_ingest_locks_col: AsyncCollection = self.db.file_ingest_locks
+        self.subscriptions_col: AsyncCollection = self.db.subscriptions
+        self.temp_passes_col: AsyncCollection = self.db.temp_passes
+        self.sub_requests_col: AsyncCollection = self.db.subscription_requests
+
+    async def _deduplicate_users(self) -> None:
+        pipeline = [
+            {"$sort": {"join_date": 1}},
+            {"$group": {"_id": "$id", "doc_id": {"$first": "$_id"}}},
+            {"$project": {"_id": "$doc_id"}}
+        ]
+        keep_ids = []
+        async for doc in self.col.aggregate(pipeline):
+            keep_ids.append(doc["_id"])
+        if keep_ids:
+            result = await self.col.delete_many({"_id": {"$nin": keep_ids}})
+            if result.deleted_count > 0:
+                logger.warning(f"Deduplicated {result.deleted_count} duplicate user documents.")
+
+    async def ensure_indexes(self, *, raise_on_error: bool = True) -> bool:
+        try:
+            await self.banned_users_col.create_index("user_id", unique=True)
+            await self.banned_channels_col.create_index("channel_id", unique=True)
+            await self.token_col.create_index("token", unique=True)
+            await self.authorized_users_col.create_index("user_id", unique=True)
+            try:
+                await self.col.create_index("id", unique=True)
+            except DuplicateKeyError:
+                logger.warning("Duplicate users found, deduplicating...")
+                await self._deduplicate_users()
+                await self.col.create_index("id", unique=True)
+            await self.token_col.create_index("expires_at", expireAfterSeconds=0)
+            await self.token_col.create_index("activated")
+            await self.restart_message_col.create_index("message_id", unique=True)
+            await self.restart_message_col.create_index("timestamp", expireAfterSeconds=3600)
+            await self.files_col.create_index("file_unique_id", unique=True)
+            await self.files_col.create_index("public_hash", unique=True)
+            await self.files_col.create_index("canonical_message_id", unique=True)
+            await self.files_col.create_index("created_at")
+            await self.files_col.create_index("last_seen_at")
+            await self.file_ingest_locks_col.create_index("expires_at", expireAfterSeconds=0)
+            await self.subscriptions_col.create_index("user_id", unique=True)
+            await self.subscriptions_col.create_index("expires_at")
+            await self.subscriptions_col.create_index("status")
+            await self.temp_passes_col.create_index([("user_id", 1), ("file_id", 1)], unique=True)
+            await self.temp_passes_col.create_index("expires_at", expireAfterSeconds=0)
+            await self.sub_requests_col.create_index("request_id", unique=True)
+            await self.sub_requests_col.create_index("user_id")
+
+            logger.debug("Database indexes ensured.")
+            return True
+        except Exception as e:
+            logger.error(f"Error in ensure_indexes: {e}", exc_info=True)
+            if raise_on_error:
+                raise
+            return False
+
+    def new_user(self, user_id: int) -> dict:
+        try:
+            return {
+                'id': user_id,
+                'join_date': datetime.datetime.now(datetime.timezone.utc)
+            }
+        except Exception as e:
+            logger.error(f"Error in new_user for user {user_id}: {e}", exc_info=True)
+            raise
+
+    async def add_user(self, user_id: int) -> bool:
+        try:
+            result = await self.col.update_one(
+                {'id': user_id},
+                {'$setOnInsert': self.new_user(user_id)},
+                upsert=True
+            )
+            if result.upserted_id:
+                logger.debug(f"Added new user {user_id} to database.")
+                return True
+            return False
+        except Exception as e:
+            logger.error(f"Error in add_user for user {user_id}: {e}", exc_info=True)
+            raise
+
+
+    async def is_user_exist(self, user_id: int) -> bool:
+        """Read-only existence check. For user registration, use add_user() instead."""
+        try:
+            user = await self.col.find_one({'id': user_id}, {'_id': 1})
+            return bool(user)
+        except Exception as e:
+            logger.error(f"Error in is_user_exist for user {user_id}: {e}", exc_info=True)
+            raise
+
+    async def total_users_count(self) -> int:
+        try:
+            return await self.col.count_documents({})
+        except Exception as e:
+            logger.error(f"Error in total_users_count: {e}", exc_info=True)
+            return 0
+
+    async def get_authorized_users_count(self) -> int:
+        try:
+            return await self.authorized_users_col.count_documents({})
+        except Exception as e:
+            logger.error(f"Error in get_authorized_users_count: {e}", exc_info=True)
+            return 0
+
+    async def get_regular_users_count(self) -> int:
+        try:
+            auth_ids = await self.authorized_users_col.distinct("user_id")
+            return await self.col.count_documents({"id": {"$nin": auth_ids}})
+        except Exception as e:
+            logger.error(f"Error in get_regular_users_count: {e}", exc_info=True)
+            return 0
+
+    async def get_all_users(self):
+        try:
+            return self.col.find({})
+        except Exception as e:
+            logger.error(f"Error in get_all_users: {e}", exc_info=True)
+            return self.col.find({"_id": {"$exists": False}})
+
+    async def get_authorized_users_cursor(self):
+        try:
+            return self.authorized_users_col.find({})
+        except Exception as e:
+            logger.error(f"Error in get_authorized_users_cursor: {e}", exc_info=True)
+            return self.authorized_users_col.find({"_id": {"$exists": False}})
+
+    async def get_regular_users_cursor(self):
+        try:
+            auth_ids = await self.authorized_users_col.distinct("user_id")
+            return self.col.find({"id": {"$nin": auth_ids}})
+        except Exception as e:
+            logger.error(f"Error in get_regular_users_cursor: {e}", exc_info=True)
+            return self.col.find({"_id": {"$exists": False}})
+
+    async def delete_user(self, user_id: int):
+        try:
+            await self.col.delete_one({'id': user_id})
+            logger.debug(f"Deleted user {user_id}.")
+        except Exception as e:
+            logger.error(f"Error in delete_user for user {user_id}: {e}", exc_info=True)
+            raise
+
+
+    async def add_banned_user(
+        self, user_id: int, banned_by: Optional[int] = None,
+        reason: Optional[str] = None
+    ):
+        try:
+            ban_data = {
+                "user_id": user_id,
+                "banned_at": datetime.datetime.now(datetime.timezone.utc),
+                "banned_by": banned_by,
+                "reason": reason
+            }
+            await self.banned_users_col.update_one(
+                {"user_id": user_id},
+                {"$set": ban_data},
+                upsert=True
+            )
+            logger.debug(f"Added/Updated banned user {user_id}. Reason: {reason}")
+        except Exception as e:
+            logger.error(f"Error in add_banned_user for user {user_id}: {e}", exc_info=True)
+            raise
+
+    async def remove_banned_user(self, user_id: int) -> bool:
+        try:
+            result = await self.banned_users_col.delete_one({"user_id": user_id})
+            if result.deleted_count > 0:
+                logger.debug(f"Removed banned user {user_id}.")
+                return True
+            return False
+        except Exception as e:
+            logger.error(f"Error in remove_banned_user for user {user_id}: {e}", exc_info=True)
+            return False
+
+    async def is_user_banned(self, user_id: int) -> Optional[Dict[str, Any]]:
+        try:
+            return await self.banned_users_col.find_one({"user_id": user_id})
+        except Exception as e:
+            logger.error(f"Error in is_user_banned for user {user_id}: {e}", exc_info=True)
+            return None
+
+    async def add_banned_channel(
+        self, channel_id: int, banned_by: Optional[int] = None,
+        reason: Optional[str] = None
+    ):
+        try:
+            ban_data = {
+                "channel_id": channel_id,
+                "banned_at": datetime.datetime.now(datetime.timezone.utc),
+                "banned_by": banned_by,
+                "reason": reason
+            }
+            await self.banned_channels_col.update_one(
+                {"channel_id": channel_id},
+                {"$set": ban_data},
+                upsert=True
+            )
+            logger.debug(f"Added/Updated banned channel {channel_id}. Reason: {reason}")
+        except Exception as e:
+            logger.error(f"Error in add_banned_channel for channel {channel_id}: {e}", exc_info=True)
+            raise
+
+    async def remove_banned_channel(self, channel_id: int) -> bool:
+        try:
+            result = await self.banned_channels_col.delete_one({"channel_id": channel_id})
+            if result.deleted_count > 0:
+                logger.debug(f"Removed banned channel {channel_id}.")
+                return True
+            return False
+        except Exception as e:
+            logger.error(f"Error in remove_banned_channel for channel {channel_id}: {e}", exc_info=True)
+            return False
+
+    async def is_channel_banned(self, channel_id: int) -> Optional[Dict[str, Any]]:
+        try:
+            return await self.banned_channels_col.find_one({"channel_id": channel_id})
+        except Exception as e:
+            logger.error(f"Error in is_channel_banned for channel {channel_id}: {e}", exc_info=True)
+            return None
+
+    async def save_main_token(self, user_id: int, token_value: str, expires_at: datetime.datetime, created_at: datetime.datetime, activated: bool) -> None:
+        try:
+            await self.token_col.update_one(
+                {"user_id": user_id, "token": token_value},
+                {"$set": {
+                    "expires_at": expires_at,
+                    "created_at": created_at,
+                    "activated": activated
+                    }
+                },
+                upsert=True
+            )
+            logger.debug(f"Saved main token {token_value} for user {user_id} with activated status {activated}.")
+        except Exception as e:
+            logger.error(f"Error saving main token for user {user_id}: {e}", exc_info=True)
+            raise
+
+
+    async def add_restart_message(self, message_id: int, chat_id: int) -> None:
+        try:
+            await self.restart_message_col.insert_one({
+                "message_id": message_id,
+                "chat_id": chat_id,
+                "timestamp": datetime.datetime.now(datetime.timezone.utc)
+            })
+            logger.debug(f"Added restart message {message_id} for chat {chat_id}.")
+        except Exception as e:
+            logger.error(f"Error adding restart message {message_id}: {e}", exc_info=True)
+
+    async def get_restart_message(self) -> Optional[Dict[str, Any]]:
+        try:
+            return await self.restart_message_col.find_one(sort=[("timestamp", -1)])
+        except Exception as e:
+            logger.error(f"Error getting restart message: {e}", exc_info=True)
+            return None
+
+    async def delete_restart_message(self, message_id: int) -> None:
+        try:
+            await self.restart_message_col.delete_one({"message_id": message_id})
+            logger.debug(f"Deleted restart message {message_id}.")
+        except Exception as e:
+            logger.error(f"Error deleting restart message {message_id}: {e}", exc_info=True)
+
+    async def is_user_authorized(self, user_id: int) -> bool:
+        try:
+            user = await self.authorized_users_col.find_one({'user_id': user_id}, {'_id': 1})
+            return bool(user)
+        except Exception as e:
+            logger.error(f"Error in is_user_authorized for user {user_id}: {e}", exc_info=True)
+            return False
+
+    async def get_file_by_unique_id(self, file_unique_id: str) -> Optional[Dict[str, Any]]:
+        try:
+            return await self.files_col.find_one({"file_unique_id": file_unique_id})
+        except Exception as e:
+            logger.error(f"Error getting file by unique_id {file_unique_id}: {e}", exc_info=True)
+            return None
+
+    async def get_file_by_hash(
+        self,
+        public_hash: str,
+        *,
+        raise_on_error: bool = True
+    ) -> Optional[Dict[str, Any]]:
+        try:
+            return await self.files_col.find_one({"public_hash": public_hash})
+        except Exception as e:
+            logger.error(f"Error getting file by hash {public_hash}: {e}", exc_info=True)
+            if raise_on_error:
+                raise
+            return None
+
+    async def get_file_by_message_id(self, canonical_message_id: int) -> Optional[Dict[str, Any]]:
+        try:
+            return await self.files_col.find_one({"canonical_message_id": canonical_message_id})
+        except Exception as e:
+            logger.error(
+                f"Error getting file by message_id {canonical_message_id}: {e}",
+                exc_info=True
+            )
+            return None
+
+    async def create_file_record(self, file_record: Dict[str, Any]) -> None:
+        try:
+            await self.files_col.insert_one(file_record)
+        except Exception as e:
+            logger.error(
+                f"Error creating canonical file record for {file_record.get('file_unique_id')}: {e}",
+                exc_info=True
+            )
+            raise
+
+    async def replace_file_record(self, file_record: Dict[str, Any]) -> None:
+        try:
+            await self.files_col.replace_one(
+                {"file_unique_id": file_record["file_unique_id"]},
+                file_record,
+                upsert=True
+            )
+        except Exception as e:
+            logger.error(
+                f"Error replacing canonical file record for {file_record.get('file_unique_id')}: {e}",
+                exc_info=True
+            )
+            raise
+
+    async def touch_file_record(
+        self,
+        public_hash: str,
+        *,
+        reused: bool = False,
+        raise_on_error: bool = False
+    ) -> bool:
+        try:
+            update_doc: Dict[str, Any] = {
+                "$set": {"last_seen_at": datetime.datetime.now(datetime.timezone.utc)},
+                "$inc": {"seen_count": 1}
+            }
+            if reused:
+                update_doc["$inc"]["reuse_count"] = 1
+            await self.files_col.update_one({"public_hash": public_hash}, update_doc)
+            return True
+        except Exception as e:
+            logger.error(f"Error touching canonical file {public_hash}: {e}", exc_info=True)
+            if raise_on_error:
+                raise
+            return False
+
+    async def update_file_id(
+        self,
+        public_hash: str,
+        file_id: str,
+        *,
+        raise_on_error: bool = False
+    ) -> bool:
+        try:
+            await self.files_col.update_one(
+                {"public_hash": public_hash},
+                {
+                    "$set": {
+                        "file_id": file_id,
+                        "last_seen_at": datetime.datetime.now(datetime.timezone.utc)
+                    }
+                }
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Error updating file_id for {public_hash}: {e}", exc_info=True)
+            if raise_on_error:
+                raise
+            return False
+
+    async def acquire_file_ingest_claim(
+        self,
+        file_unique_id: str,
+        *,
+        ttl_seconds: int = 60
+    ) -> bool:
+        now = datetime.datetime.now(datetime.timezone.utc)
+        claim_fields = {
+            "created_at": now,
+            "expires_at": now + datetime.timedelta(seconds=ttl_seconds)
+        }
+        try:
+            await self.file_ingest_locks_col.insert_one({
+                "_id": file_unique_id,
+                **claim_fields
+            })
+            return True
+        except DuplicateKeyError:
+            try:
+                result = await self.file_ingest_locks_col.find_one_and_update(
+                    {
+                        "_id": file_unique_id,
+                        "$or": [
+                            {"expires_at": {"$lte": now}},
+                            {"expires_at": {"$exists": False}}
+                        ]
+                    },
+                    {
+                        "$set": claim_fields
+                    },
+                    return_document=False
+                )
+                return bool(result)
+            except Exception as e:
+                logger.error(f"Error updating ingest claim for {file_unique_id}: {e}", exc_info=True)
+                raise
+        except Exception as e:
+            logger.error(f"Error acquiring ingest claim for {file_unique_id}: {e}", exc_info=True)
+            raise
+
+    async def release_file_ingest_claim(self, file_unique_id: str) -> bool:
+        try:
+            await self.file_ingest_locks_col.delete_one({"_id": file_unique_id})
+            return True
+        except Exception as e:
+            logger.error(f"Error releasing ingest claim for {file_unique_id}: {e}", exc_info=True)
+            return False
+
+    async def is_file_ingest_claim_active(self, file_unique_id: str) -> bool:
+        try:
+            claim = await self.file_ingest_locks_col.find_one(
+                {
+                    "_id": file_unique_id,
+                    "expires_at": {"$gt": datetime.datetime.now(datetime.timezone.utc)}
+                },
+                {"_id": 1}
+            )
+            return bool(claim)
+        except Exception as e:
+            logger.error(f"Error checking ingest claim for {file_unique_id}: {e}", exc_info=True)
+            raise
+
+
+    async def is_subscribed(self, user_id: int) -> bool:
+        try:
+            now = datetime.datetime.now(datetime.timezone.utc)
+            doc = await self.subscriptions_col.find_one({
+                "user_id": user_id,
+                "status": "active",
+                "expires_at": {"$gt": now}
+            })
+            return bool(doc)
+        except Exception as e:
+            logger.error(f"Error checking subscription for user {user_id}: {e}", exc_info=True)
+            return False
+
+    async def get_subscription(self, user_id: int) -> Optional[Dict[str, Any]]:
+        try:
+            return await self.subscriptions_col.find_one({"user_id": user_id})
+        except Exception as e:
+            logger.error(f"Error getting subscription for user {user_id}: {e}", exc_info=True)
+            return None
+
+    async def add_subscription(self, user_id: int, days: int = 30, tx_ref: str = "", plan: str = "monthly") -> Dict[str, Any]:
+        try:
+            now = datetime.datetime.now(datetime.timezone.utc)
+            existing = await self.get_subscription(user_id)
+            if existing and existing.get("status") == "active" and existing.get("expires_at") and existing["expires_at"] > now:
+                new_expiry = existing["expires_at"] + datetime.timedelta(days=days)
+            else:
+                new_expiry = now + datetime.timedelta(days=days)
+
+            doc = {
+                "user_id": user_id,
+                "plan": plan,
+                "status": "active",
+                "activated_at": now,
+                "expires_at": new_expiry,
+                "tx_ref": tx_ref or (existing.get("tx_ref", "") if existing else "")
+            }
+            await self.subscriptions_col.update_one(
+                {"user_id": user_id},
+                {"$set": doc},
+                upsert=True
+            )
+            logger.info(f"Subscription added for user {user_id}: valid until {new_expiry.isoformat()}")
+            return doc
+        except Exception as e:
+            logger.error(f"Error adding subscription for user {user_id}: {e}", exc_info=True)
+            raise
+
+    async def remove_subscription(self, user_id: int) -> bool:
+        try:
+            res = await self.subscriptions_col.update_one(
+                {"user_id": user_id},
+                {"$set": {"status": "revoked", "revoked_at": datetime.datetime.now(datetime.timezone.utc)}}
+            )
+            return res.modified_count > 0
+        except Exception as e:
+            logger.error(f"Error removing subscription for user {user_id}: {e}", exc_info=True)
+            return False
+
+    async def get_active_subscribers_count(self) -> int:
+        try:
+            now = datetime.datetime.now(datetime.timezone.utc)
+            return await self.subscriptions_col.count_documents({
+                "status": "active",
+                "expires_at": {"$gt": now}
+            })
+        except Exception as e:
+            logger.error(f"Error counting subscribers: {e}", exc_info=True)
+            return 0
+
+    async def get_all_subscribers(self, limit: int = 50) -> list:
+        try:
+            now = datetime.datetime.now(datetime.timezone.utc)
+            cursor = self.subscriptions_col.find({
+                "status": "active",
+                "expires_at": {"$gt": now}
+            }).sort("expires_at", -1).limit(limit)
+            return [doc async for doc in cursor]
+        except Exception as e:
+            logger.error(f"Error listing subscribers: {e}", exc_info=True)
+            return []
+
+    async def add_temp_pass(self, user_id: int, file_id: str, hours: int = 24) -> bool:
+        try:
+            now = datetime.datetime.now(datetime.timezone.utc)
+            expiry = now + datetime.timedelta(hours=hours)
+            await self.temp_passes_col.update_one(
+                {"user_id": user_id, "file_id": str(file_id)},
+                {"$set": {"created_at": now, "expires_at": expiry, "used": False}},
+                upsert=True
+            )
+            logger.info(f"Temporary pass added for user {user_id}, file {file_id} (valid {hours}h)")
+            return True
+        except Exception as e:
+            logger.error(f"Error adding temp pass for {user_id}: {e}", exc_info=True)
+            return False
+
+    async def has_temp_pass(self, user_id: int, file_id: str) -> bool:
+        try:
+            now = datetime.datetime.now(datetime.timezone.utc)
+            doc = await self.temp_passes_col.find_one({
+                "user_id": user_id,
+                "file_id": str(file_id),
+                "expires_at": {"$gt": now}
+            })
+            return bool(doc)
+        except Exception as e:
+            logger.error(f"Error checking temp pass for {user_id}: {e}", exc_info=True)
+            return False
+
+    async def create_sub_request(
+        self,
+        user_id: int,
+        user_name: str,
+        req_type: str,
+        file_id: Optional[str] = None,
+        tx_ref: Optional[str] = None,
+        proof_file_id: Optional[str] = None
+    ) -> str:
+        try:
+            req_id = secrets.token_hex(6)
+            doc = {
+                "request_id": req_id,
+                "user_id": user_id,
+                "user_name": user_name,
+                "req_type": req_type,
+                "file_id": str(file_id) if file_id else None,
+                "tx_ref": tx_ref,
+                "proof_file_id": proof_file_id,
+                "status": "pending",
+                "created_at": datetime.datetime.now(datetime.timezone.utc)
+            }
+            await self.sub_requests_col.insert_one(doc)
+            return req_id
+        except Exception as e:
+            logger.error(f"Error creating subscription request: {e}", exc_info=True)
+            raise
+
+    async def get_sub_request(self, request_id: str) -> Optional[Dict[str, Any]]:
+        try:
+            return await self.sub_requests_col.find_one({"request_id": request_id})
+        except Exception as e:
+            logger.error(f"Error fetching subscription request {request_id}: {e}", exc_info=True)
+            return None
+
+    async def update_sub_request_status(self, request_id: str, status: str, admin_id: int) -> bool:
+        try:
+            res = await self.sub_requests_col.update_one(
+                {"request_id": request_id},
+                {"$set": {
+                    "status": status,
+                    "decided_by": admin_id,
+                    "decided_at": datetime.datetime.now(datetime.timezone.utc)
+                }}
+            )
+            return res.modified_count > 0
+        except Exception as e:
+            logger.error(f"Error updating request {request_id}: {e}", exc_info=True)
+            return False
+
+    async def close(self):
+        if self._client:
+            await self._client.close()
+
+db = Database(Var.DATABASE_URL, Var.NAME)

Thunder/utils/messages.py

@@ -1,399 +1,454 @@
-# Thunder/utils/messages.py
-
-# =====================================================================================
-# ====== ERROR MESSAGES ======
-# =====================================================================================
-
-# ------ General Errors ------
-MSG_ERROR_GENERIC = "⚠️ **Oops!** Something went wrong. Please try again. If the issue persists, contact support."
-MSG_ERROR_USER_INFO = "❗ **User Not Found:** Couldn't find user. Please check the ID or Username."
-
-# ------ User Input & Validation Errors ------
-MSG_INVALID_USER_ID = "❌ **Invalid User ID:** Please provide a numeric user ID."
-MSG_ERROR_START_BOT = "⚠️ You need to start the bot in private first to use this command.\n👉 [Click here]({invite_link}) to start a private chat."
-MSG_ERROR_REPLY_FILE = "⚠️ Please use the /link command in reply to a file."
-MSG_ERROR_NO_FILE = "⚠️ The message you're replying to does not contain any file."
-MSG_ERROR_INVALID_NUMBER = "⚠️ **Invalid number specified.**"
-MSG_ERROR_NUMBER_RANGE = "⚠️ **Please specify a number between 1 and {max_files}.**"
-MSG_ERROR_DM_FAILED = "⚠️ I couldn't send you a Direct Message. Please start the bot first."
-
-# ------ File & Media Errors ------
-MSG_ERROR_PROCESSING_MEDIA = "⚠️ **Oops!** Something went wrong while processing your media. Please try again. If the issue persists, contact support."
-
-# ------ Admin Action Errors (Ban, Auth, etc.) ------
-MSG_AUTHORIZE_FAILED = (
-    "❌ **Authorization Failed:** "
-    "Could not authorize user `{user_id}`."
-)
-MSG_DEAUTHORIZE_FAILED = (
-    "❌ **Deauthorization Failed:** "
-    "User `{user_id}` was not authorized or an error occurred."
-)
-MSG_TOKEN_FAILED = (
-    "⚠️ **Token Activation Failed!**\n\n"
-    "> ❗ Reason: {reason}\n\n"
-    "🔑 Please check your token or contact support."
-)
-MSG_SHELL_ERROR = """**❌ Shell Command Error ❌**
-<pre>{error}</pre>"""
-
-# ------ System & Bot Errors ------
-MSG_ERROR_NOT_ADMIN = "⚠️ **Admin Required:** I need admin privileges to work here."
-MSG_DC_INVALID_USAGE = "🤔 **Invalid Usage:** Please reply to a user's message or a media file to get DC info."
-MSG_DC_ANON_ERROR = "😥 **Cannot Get Your DC Info:** Unable to identify you. This command might not work for anonymous users."
-MSG_DC_FILE_ERROR = "⚙️ **Error Getting File DC Info:** Could not fetch details. File might be inaccessible."
-MSG_STATS_ERROR = "❌ **Stats Error:** Could not retrieve system statistics."
-MSG_STATUS_ERROR = "❌ **Status Error:** Could not retrieve system status."
-MSG_DB_ERROR = "❌ **Database Error:** Could not retrieve user count."
-MSG_CRITICAL_ERROR = (
-    "🚨 **Critical Media Processing Error** 🚨\n\n"
-    "> ⚠️ Details:\n```\n{error}\n```\n\n"
-    "Please investigate immediately! (ID: {error_id})"
-)
-
-# =====================================================================================
-# ====== ADMIN MESSAGES ======
-# =====================================================================================
-
-# ------ Ban/Unban ------
-MSG_DECORATOR_BANNED = "You are currently banned and cannot use this bot.\nReason: {reason}\nBanned on: {ban_time}"
-MSG_BAN_USAGE = "⚠️ **Usage:** /ban [user_id] [reason]"
-MSG_CANNOT_BAN_OWNER = "❌ **Cannot ban an owner.**"
-MSG_ADMIN_USER_BANNED = "✅ **User {user_id} has been banned."
-MSG_BAN_REASON_SUFFIX = "\n📝 **Reason:** {reason}"
-MSG_ADMIN_NO_BAN_REASON = "No reason provided"
-MSG_USER_BANNED_NOTIFICATION = "🚫 **You have been banned from using this bot.**"
-MSG_UNBAN_USAGE = "⚠️ **Usage:** /unban <user_id>"
-MSG_ADMIN_USER_UNBANNED = "✅ **User {user_id} has been unbanned."
-MSG_USER_UNBANNED_NOTIFICATION = "🎉 **You have been unbanned from using this bot.**"
-MSG_USER_NOT_IN_BAN_LIST = "ℹ️ **User {user_id} was not found in the ban list."
-MSG_CHANNEL_BANNED = "✅ **Channel {channel_id} has been banned.**"
-MSG_CHANNEL_BANNED_REASON_SUFFIX = "\n📝 **Reason:** {reason}"
-MSG_CHANNEL_UNBANNED = "✅ **Channel {channel_id} has been unbanned.**"
-MSG_CHANNEL_NOT_BANNED = "ℹ️ **Channel {channel_id} was not found in the ban list.**"
-
-# ------ Token & Authorization ------
-MSG_AUTHORIZE_USAGE = "🔑 **Usage:** `/authorize <user_id>`"
-MSG_DEAUTHORIZE_USAGE = "🔒 **Usage:** `/deauthorize <user_id>`"
-MSG_AUTHORIZE_SUCCESS = (
-    "✅ **User Authorized!**\n\n"
-    "> 👤 User ID: `{user_id}`\n"
-    "> 🔑 Access: Permanent"
-)
-MSG_DEAUTHORIZE_SUCCESS = (
-    "✅ **User Deauthorized!**\n\n"
-    "> 👤 User ID: `{user_id}`\n"
-    "> 🔒 Access: Revoked"
-)
-MSG_TOKEN_ACTIVATED = "✅ Token successfully activated!\n\n⏳ This token is valid for {duration_hours} hours."
-MSG_TOKEN_INVALID = "🚫 **Expired or Invalid Token.** Please click the button below to activate your access token."
-MSG_NO_AUTH_USERS = "ℹ️ **No Authorized Users Found:** The list is currently empty."
+# Thunder/utils/messages.py
+
+# =====================================================================================
+# ====== ERROR MESSAGES ======
+# =====================================================================================
+
+# ------ General Errors ------
+MSG_ERROR_GENERIC = "⚠️ **Oops!** Something went wrong. Please try again. If the issue persists, contact support."
+MSG_ERROR_USER_INFO = "❗ **User Not Found:** Couldn't find user. Please check the ID or Username."
+
+# ------ User Input & Validation Errors ------
+MSG_INVALID_USER_ID = "❌ **Invalid User ID:** Please provide a numeric user ID."
+MSG_ERROR_START_BOT = "⚠️ You need to start the bot in private first to use this command.\n👉 [Click here]({invite_link}) to start a private chat."
+MSG_ERROR_REPLY_FILE = "⚠️ Please use the /link command in reply to a file."
+MSG_ERROR_NO_FILE = "⚠️ The message you're replying to does not contain any file."
+MSG_ERROR_INVALID_NUMBER = "⚠️ **Invalid number specified.**"
+MSG_ERROR_NUMBER_RANGE = "⚠️ **Please specify a number between 1 and {max_files}.**"
+MSG_ERROR_DM_FAILED = "⚠️ I couldn't send you a Direct Message. Please start the bot first."
+
+# ------ File & Media Errors ------
+MSG_ERROR_PROCESSING_MEDIA = "⚠️ **Oops!** Something went wrong while processing your media. Please try again. If the issue persists, contact support."
+
+# ------ Admin Action Errors (Ban, Auth, etc.) ------
+MSG_AUTHORIZE_FAILED = (
+    "❌ **Authorization Failed:** "
+    "Could not authorize user `{user_id}`."
+)
+MSG_DEAUTHORIZE_FAILED = (
+    "❌ **Deauthorization Failed:** "
+    "User `{user_id}` was not authorized or an error occurred."
+)
+MSG_TOKEN_FAILED = (
+    "⚠️ **Token Activation Failed!**\n\n"
+    "> ❗ Reason: {reason}\n\n"
+    "🔑 Please check your token or contact support."
+)
+MSG_SHELL_ERROR = """**❌ Shell Command Error ❌**
+<pre>{error}</pre>"""
+
+# ------ System & Bot Errors ------
+MSG_ERROR_NOT_ADMIN = "⚠️ **Admin Required:** I need admin privileges to work here."
+MSG_DC_INVALID_USAGE = "🤔 **Invalid Usage:** Please reply to a user's message or a media file to get DC info."
+MSG_DC_ANON_ERROR = "😥 **Cannot Get Your DC Info:** Unable to identify you. This command might not work for anonymous users."
+MSG_DC_FILE_ERROR = "⚙️ **Error Getting File DC Info:** Could not fetch details. File might be inaccessible."
+MSG_STATS_ERROR = "❌ **Stats Error:** Could not retrieve system statistics."
+MSG_STATUS_ERROR = "❌ **Status Error:** Could not retrieve system status."
+MSG_DB_ERROR = "❌ **Database Error:** Could not retrieve user count."
+MSG_CRITICAL_ERROR = (
+    "🚨 **Critical Media Processing Error** 🚨\n\n"
+    "> ⚠️ Details:\n```\n{error}\n```\n\n"
+    "Please investigate immediately! (ID: {error_id})"
+)
+
+# =====================================================================================
+# ====== ADMIN MESSAGES ======
+# =====================================================================================
+
+# ------ Ban/Unban ------
+MSG_DECORATOR_BANNED = "You are currently banned and cannot use this bot.\nReason: {reason}\nBanned on: {ban_time}"
+MSG_BAN_USAGE = "⚠️ **Usage:** /ban [user_id] [reason]"
+MSG_CANNOT_BAN_OWNER = "❌ **Cannot ban an owner.**"
+MSG_ADMIN_USER_BANNED = "✅ **User {user_id} has been banned."
+MSG_BAN_REASON_SUFFIX = "\n📝 **Reason:** {reason}"
+MSG_ADMIN_NO_BAN_REASON = "No reason provided"
+MSG_USER_BANNED_NOTIFICATION = "🚫 **You have been banned from using this bot.**"
+MSG_UNBAN_USAGE = "⚠️ **Usage:** /unban <user_id>"
+MSG_ADMIN_USER_UNBANNED = "✅ **User {user_id} has been unbanned."
+MSG_USER_UNBANNED_NOTIFICATION = "🎉 **You have been unbanned from using this bot.**"
+MSG_USER_NOT_IN_BAN_LIST = "ℹ️ **User {user_id} was not found in the ban list."
+MSG_CHANNEL_BANNED = "✅ **Channel {channel_id} has been banned.**"
+MSG_CHANNEL_BANNED_REASON_SUFFIX = "\n📝 **Reason:** {reason}"
+MSG_CHANNEL_UNBANNED = "✅ **Channel {channel_id} has been unbanned.**"
+MSG_CHANNEL_NOT_BANNED = "ℹ️ **Channel {channel_id} was not found in the ban list.**"
+
+# ------ Token & Authorization ------
+MSG_AUTHORIZE_USAGE = "🔑 **Usage:** `/authorize <user_id>`"
+MSG_DEAUTHORIZE_USAGE = "🔒 **Usage:** `/deauthorize <user_id>`"
+MSG_AUTHORIZE_SUCCESS = (
+    "✅ **User Authorized!**\n\n"
+    "> 👤 User ID: `{user_id}`\n"
+    "> 🔑 Access: Permanent"
+)
+MSG_DEAUTHORIZE_SUCCESS = (
+    "✅ **User Deauthorized!**\n\n"
+    "> 👤 User ID: `{user_id}`\n"
+    "> 🔒 Access: Revoked"
+)
+MSG_TOKEN_ACTIVATED = "✅ Token successfully activated!\n\n⏳ This token is valid for {duration_hours} hours."
+MSG_TOKEN_INVALID = "🚫 **Expired or Invalid Token.** Please click the button below to activate your access token."
+MSG_NO_AUTH_USERS = "ℹ️ **No Authorized Users Found:** The list is currently empty."
 MSG_AUTH_USER_INFO = """{i}. 👤: {display_name}
    • User ID: `{user_id}`
    • Authorized by: `{authorized_by}`
    • Date: `{auth_time}`\n\n"""
-MSG_ADMIN_AUTH_LIST_HEADER = "🔐 **Authorized Users List**\n\n"
-
-# ------ Shell Commands ------
-MSG_SHELL_USAGE = (
-    "<b>Usage:</b>\n"
-    "/shell <command>\n\n"
-    "<b>Example:</b>\n"
-    "/shell ls -l"
-)
-MSG_SHELL_EXECUTING = "Executing Command... ⚙️\n<pre>{command}</pre>"
-MSG_SHELL_OUTPUT = """**Shell Command Output:**
-<pre>{output}</pre>"""
-MSG_SHELL_OUTPUT_STDOUT = "<b>[stdout]:</b>\n<pre>{output}</pre>"
-MSG_SHELL_OUTPUT_STDERR = "<b>[stderr]:</b>\n<pre>{error}</pre>"
-MSG_SHELL_NO_OUTPUT = "✅ <b>Command Executed:</b> No output."
-
-# ------ Admin View & Control ------
-
-MSG_WORKLOAD_ITEM = "   {bot_name}: {load}\n"
-MSG_ADMIN_RESTART_DONE = "✅ **Restart Successful!**"
-MSG_RESTARTING = "♻️ **Updating and Restarting Bot...**\n\n> ⏳ Please wait a moment."
-MSG_LOG_FILE_CAPTION = "📄 **System Logs**"
-
-MSG_LOG_FILE_EMPTY = "ℹ️ **Log File Empty:** No data found in the log file."
-MSG_LOG_FILE_MISSING = "⚠️ **Log File Missing:** Could not find the log file."
-
-# =====================================================================================
-# ====== BUTTON TEXTS (User-facing) ======
-# =====================================================================================
-
-MSG_BUTTON_STREAM_NOW = "🖥️ Stream"
-MSG_BUTTON_DOWNLOAD = "🚀 Download"
-MSG_BUTTON_GET_HELP = "📖 Get Help"
-MSG_BUTTON_CANCEL_BROADCAST = "🛑 Cancel Broadcast"
-MSG_BUTTON_VIEW_PROFILE = "👤 View User Profile"
-MSG_BUTTON_ABOUT = "ℹ️ About Bot"
-MSG_BUTTON_JOIN_CHANNEL = "📢 Join {channel_title}"
-MSG_BUTTON_GITHUB = "🛠️ GitHub"
-MSG_BUTTON_START_CHAT = "📩 Start Chat"
-MSG_BUTTON_CLOSE = "✖ Close"
-
-
-# =====================================================================================
-# ====== COMMAND RESPONSES (User-facing) ======
-# =====================================================================================
-
-MSG_WELCOME = (
-    "🌟 **Welcome, {user_name}!** 🌟\n\n"
-    "I'm **Flash File** ⚡\n"
-    "I generate direct download and streaming links for your files.\n\n"
-    "**How to use:**\n"
-    "1. Send any file to me for private links.\n"
-    "2. In groups, reply to a file with `/link`.\n\n"
-    "» Use `/help` for all commands and detailed information.\n\n"
-    "🚀 Send a file to begin!"
-)
-
-MSG_HELP = (
-    "📘 **Flash File - Help Guide** 📖\n\n"
-    "How to get direct download & streaming links:\n\n"
-    "**🚀 Private Chat (with me):**\n"
-    "> 1. Send me **any file** (document, video, audio, photo, etc.).\n"
-    "> 2. I'll instantly reply with your links! ⚡\n\n"
-    "**👥 Using in Groups:**\n"
-    "> • Reply to any file with `/link`.\n"
-    "> • **Batch Mode:** Reply to the **first** file with `/link <number>` (e.g., `/link 5` for 5 files, up to {max_files}).\n"
-    "> • Bot needs administrator rights in the group to function.\n"
-    "> • Links are posted in the group & sent to you privately.\n\n"
-    "**📢 Using in Channels:**\n"
-    "> • Add me as an administrator with necessary permissions.\n"
-    "> • I can be configured to auto-detect new media files.\n"
-    "> • Inline stream/download buttons can be added to files automatically.\n"
-    "> • Files from banned channels (owner configuration) are rejected.\n"
-    "> • Auto-posting links if the bot has admin privileges with delete rights.\n\n"
-    "**⚙️ Available Commands:**\n"
-    "> `/start` 👋 - Welcome message & quick start information.\n"
-    "> `/help` 📖 - Shows this help message.\n"
-    "> `/link <num>` 🔗 - (Groups) Generate links. \n"
-    "> `/about` ℹ️ - Learn more about me and my features.\n"
-    "> `/ping` 📡 - Check my responsiveness and online status.\n"
-    "> `/dc` 🌍 - View DC information (for yourself, another user, or a file).\n\n"
-    "**💡 Pro Tips:**\n"
-    "> • You can forward files from other chats directly to me.\n"
-    "> • If you encounter a rate limit message, please wait the specified time. ⏳\n"
-    "> • For `/link` in groups to work reliably (and for private link delivery), ensure you've started a private chat with me first.\n"
-    "> • Processing batch files might take a bit longer. Please be patient. 🐌\n\n"
-    "❓ Questions? Please ask in our support group!"
-)
-
-MSG_ABOUT = (
-    "🌟 **About Flash File - File to Link Bot** ℹ️\n\n"
-    "I'm your go-to bot for **instant download & streaming!** ⚡\n\n"
-    "**🚀 Key Features:**\n"
-    "> **Instant Links:** Get your links within seconds.\n"
-    "> **Online Streaming:** Watch videos or listen to audio directly (for supported formats).\n"
-    "> **Universal File Support:** Handles documents, videos, audio, photos, and more.\n"
-    "> **High-Speed Access:** Optimized for fast link generation and file access.\n"
-    "> **Secure & Reliable:** Your files are handled with care during processing.\n"
-    "> **User-Friendly Interface:** Designed for ease of use on any device.\n"
-    "> **Efficient Processing:** Built for speed and reliability.\n"
-    "> **Batch Mode:** Process multiple files at once in groups using `/link <number>`.\n"
-    "> **Versatile Usage:** Works in private chats, groups, and channels (with admin setup).\n\n"
-    "💖 If you find me useful, please consider sharing me with your friends!"
-)
-
-# ------ Ping ------
-MSG_PING_START = "🛰️ **Pinging...** Please wait."
-MSG_PING_RESPONSE = (
-    "☁️ **PONG! Bot is Online!** ⚡\n\n"
-    "> ⏱️ **Ping:** {time_taken_ms:.2f} ms\n"
-    "> 🤖 **Bot Status:** `Active`"
-)
-
-# ------ DC Info ------
-MSG_DC_USER_INFO = (
-    "📍 **Information**\n"
-    "> 👤 **User:** [{user_name}](tg://user?id={user_id})\n"
-    "> 🆔 **User ID:** `{user_id}`\n"
-    "> 🌍 **DC ID:** `{dc_id}`"
-)
-
-MSG_DC_FILE_INFO = (
-    "🗂️ **File Information**\n"
-    ">`{file_name}`\n"
-    "💾 **File Size:** `{file_size}`\n"
-    "📁 **File Type:** `{file_type}`\n"
-    "🌍 **DC ID:** `{dc_id}`"
-)
-
-MSG_DC_UNKNOWN = "Unknown"
-
-# ------ File Link Generation ------
-MSG_DM_SINGLE_PREFIX = "📬 **From {chat_title}**\n"
-MSG_LINKS = (
-    "✨ **Your Links are Ready!** ✨\n\n"
-    "> `{file_name}`\n\n"
-    "📂 **File Size:** `{file_size}`\n\n"
-    "🚀 **Download Link:**\n`{download_link}`\n\n"
-    "🖥️ **Stream Link:**\n`{stream_link}`\n\n"
-    "⌛️ **Note: Links remain active while the bot is running and the file is accessible.**"
-)
-
-# =====================================================================================
-# ====== USER NOTIFICATIONS ======
-# =====================================================================================
-
-MSG_NEW_USER = (
-    "✨ **New User Alert!** ✨\n"
-    "> 👤 **Name:** [{first_name}](tg://user?id={user_id})\n"
-    "> 🆔 **User ID:** `{user_id}`\n\n"
-)
-MSG_COMMUNITY_CHANNEL = "📢 **{channel_title}:** 🔒 Join this channel to use the bot."
-
-# =====================================================================================
-# ====== PROCESSING MESSAGES ======
-# =====================================================================================
-
-# ------ General File Processing ------
-MSG_PROCESSING_REQUEST = "⏳ **Processing your request...**"
-MSG_PROCESSING_FILE = "⏳ **Processing your file...**"
-MSG_NEW_FILE_REQUEST = (
-    "> 👤 **Source:** [{source_info}](tg://user?id={id_})\n"
-    "> 🆔 **ID:** `{id_}`\n\n"
-    "🚀 **Download:** `{online_link}`\n\n"
-    "🖥️ **Stream:** `{stream_link}`"
-)
-
-# ------ Batch Processing ------
-MSG_PROCESSING_BATCH = "♻️ **Processing Batch {batch_number}/{total_batches}** ({file_count} files)"
-MSG_PROCESSING_STATUS = "📊 **Processing Files:** {processed}/{total} complete, {failed} failed"
-MSG_BATCH_LINKS_READY = "🔗 Here are your {count} download links:"
-MSG_DM_BATCH_PREFIX = "📬 **Batch Links from {chat_title}**\n"
-MSG_PROCESSING_RESULT = "✅ **Process Complete:** {processed}/{total} files processed successfully, {failed} failed"
-
-# =====================================================================================
-# ====== BROADCAST MESSAGES ======
-# =====================================================================================
-
-MSG_BROADCAST_START = "📣 **Starting Broadcast...**\n\n> ⏳ Please wait for completion."
-MSG_BROADCAST_COMPLETE = (
-    "📢 **Broadcast Completed Successfully!** 📢\n\n"
-    "⏱️ **Duration:** `{elapsed_time}`\n"
-    "👥 **Total Users:** `{total_users}`\n"
-    "✅ **Successful Deliveries:** `{successes}`\n"
-    "❌ **Failed Deliveries:** `{failures}`\n"
-    "🗑️ **Accounts Removed (Blocked/Deactivated):** `{deleted_accounts}`\n"
-)
-MSG_BROADCAST_CANCEL = "🛑 **Cancelling Broadcast:** `{broadcast_id}`\n\n> ⏳ Stopping operations..."
-MSG_INVALID_BROADCAST_CMD = "Please reply to the message you want to broadcast."
-MSG_BROADCAST_USAGE = (
-    "📣 **Broadcast Command Usage:**\n\n"
-    "`/broadcast` - Broadcast to all users\n"
-    "`/broadcast authorized` - Broadcast to authorized users only\n"
-    "`/broadcast regular` - Broadcast to regular (non-authorized) users only\n\n"
-    "**Note:** Reply to the message you want to broadcast."
-)
-
-# =====================================================================================
-# ====== PERMISSION MESSAGES ======
-# =====================================================================================
-
-MSG_ERROR_UNAUTHORIZED = "You are not authorized to view this information."
-MSG_ERROR_BROADCAST_RESTART = "Please use the /broadcast command to start a new broadcast."
-MSG_ERROR_BROADCAST_INSTRUCTION = "To start a new broadcast, use the /broadcast command and reply to the message you want to broadcast."
-MSG_ERROR_CALLBACK_UNSUPPORTED = "This button is not active or no longer supported."
-
-# =====================================================================================
-# ====== RATE LIMITING MESSAGES ======
-# =====================================================================================
-
-MSG_RATE_LIMIT_QUEUE_PRIORITY = (
-    "⚡ You're in the **Priority Queue!**\n\n"
-    "> ⏳ **Estimated Wait:** `~{wait_estimate} minute{s}`\n"
-    "> 🚀 **Status:** In Queue"
-)
-
-MSG_RATE_LIMIT_QUEUE_REGULAR = (
-    "⏳ **Rate Limit Reached!**\n\n"
-    "> ⌛ **Estimated Wait:** `~{wait_estimate} minute{s1}`\n"
-    "> 📊 **Limit:** `{max_requests} files per {time_window} minute{s2}`\n"
-    "> 🔄 **Status:** In Queue"
-)
-
-MSG_RATE_LIMIT_QUEUE_FULL = (
-    "⚠️ **Service Busy!** The processing queue is currently full.\n\n"
-    "> 🕒 **Please try again in:** `~{wait_estimate} minute{s}`\n"
-    "> 💡 **Tip:** Try again later when system load decreases"
-)
-
-
-# =====================================================================================
-# ====== FILE TYPE DESCRIPTIONS ======
-# =====================================================================================
-MSG_FILE_TYPE_DOCUMENT = "📄 Document"
-MSG_FILE_TYPE_PHOTO = "🖼️ Photo"
-MSG_FILE_TYPE_VIDEO = "🎬 Video"
-MSG_FILE_TYPE_AUDIO = "🎵 Audio"
-MSG_FILE_TYPE_VOICE = "🎤 Voice Message"
-MSG_FILE_TYPE_STICKER = "🎨 Sticker"
-MSG_FILE_TYPE_ANIMATION = "🎞️ Animation (GIF)"
-MSG_FILE_TYPE_VIDEO_NOTE = "📹 Video Note"
-MSG_FILE_TYPE_UNKNOWN = "❓ Unknown File Type"
-
-# =====================================================================================
-# ====== SYSTEM & STATUS MESSAGES ======
-# =====================================================================================
-
-MSG_SYSTEM_STATUS = (
-    "✅ **System Status:** Operational\n\n"
-    "> 🕒 **Uptime:** `{uptime}`\n"
-    "> 🤖 **Bot Instances:** `{active_bots}`\n"
-    "> 📊 **Total Workload:** `{total_workload}`\n\n"
-    "📜 **Workload Distribution:**\n\n"
-    "{workload_items}\n"
-    "> ♻️ **Version:** `{version}`"
-)
-
-# ------ Speedtest Messages ------
-MSG_SPEEDTEST_INIT = "🚀 **Running Speed Test...**"
-MSG_SPEEDTEST_ERROR = "❌ **Speed Test Failed!**\n\n> Unable to complete the speed test. Please try again later."
-MSG_SPEEDTEST_RESULT = (
-    "⚡ **Speed Test Results**\n\n"
-    "**SPEEDTEST INFO:**\n"
-    "> **Download:** `{download_mbps} Mbps` (`{download_bps}/s`)\n"
-    "> **Upload:** `{upload_mbps} Mbps` (`{upload_bps}/s`)\n"
-    "> **Ping:** `{ping} ms`\n"
-    "> **Timestamp:** `{timestamp}`\n"
-    "> **Data Sent:** `{bytes_sent}`\n"
-    "> **Data Received:** `{bytes_received}`\n\n"
-    "**SERVER INFO:**\n"
-    "> **Name:** `{server_name}`\n"
-    "> **Country:** `{server_country}`\n"
-    "> **Sponsor:** `{server_sponsor}`\n"
-    "> **Latency:** `{server_latency} ms`\n"
-    "> **Coordinates:** `{server_lat}, {server_lon}`\n\n"
-    "**CLIENT DETAILS:**\n"
-    "> **IP:** `{client_ip}`\n"
-    "> **Coordinates:** `{client_lat}, {client_lon}`\n"
-    "> **ISP:** `{client_isp}`\n"
-    "> **ISP Rating:** `{client_isprating}`\n"
-    "> **Country:** `{client_country}`"
-)
-MSG_SYSTEM_STATS = (
-    "📊 **System Statistics**\n\n"
-    "> System Uptime: {sys_uptime}\n"
-    "> Bot Uptime: {bot_uptime}\n\n"
-    "⚙️ **Performance:**\n"
-    "> CPU: {cpu_percent}%\n"
-    "> CPU Core: {cpu_cores}\n"
-    "> Frequency: {cpu_freq} GHz\n\n"
-    "💾 **RAM**\n"
-    "> Total: {ram_total}\n"
-    "> Used: {ram_used}\n"
-    "> Free: {ram_free}\n\n"
-    "💽 **Storage:**\n"
-    "> Disk: `{disk_percent}%`\n"
-    "> Total: `{total}`\n"
-    "> Used: `{used}`\n"
-    "> Free: `{free}`\n\n"
-    "📶 **Network:**\n"
-    "> 🔺 Upload: `{upload}`\n"
-    "> 🔻 Download: `{download}`\n"
-)
-
-MSG_DB_STATS = "📊 **Database Statistics**\n\n> 👥 **Total Users:** `{total_users}`"
+MSG_ADMIN_AUTH_LIST_HEADER = "🔐 **Authorized Users List**\n\n"
+
+# ------ Shell Commands ------
+MSG_SHELL_USAGE = (
+    "<b>Usage:</b>\n"
+    "/shell <command>\n\n"
+    "<b>Example:</b>\n"
+    "/shell ls -l"
+)
+MSG_SHELL_EXECUTING = "Executing Command... ⚙️\n<pre>{command}</pre>"
+MSG_SHELL_OUTPUT = """**Shell Command Output:**
+<pre>{output}</pre>"""
+MSG_SHELL_OUTPUT_STDOUT = "<b>[stdout]:</b>\n<pre>{output}</pre>"
+MSG_SHELL_OUTPUT_STDERR = "<b>[stderr]:</b>\n<pre>{error}</pre>"
+MSG_SHELL_NO_OUTPUT = "✅ <b>Command Executed:</b> No output."
+
+# ------ Admin View & Control ------
+
+MSG_WORKLOAD_ITEM = "   {bot_name}: {load}\n"
+MSG_ADMIN_RESTART_DONE = "✅ **Restart Successful!**"
+MSG_RESTARTING = "♻️ **Updating and Restarting Bot...**\n\n> ⏳ Please wait a moment."
+MSG_LOG_FILE_CAPTION = "📄 **System Logs**"
+
+MSG_LOG_FILE_EMPTY = "ℹ️ **Log File Empty:** No data found in the log file."
+MSG_LOG_FILE_MISSING = "⚠️ **Log File Missing:** Could not find the log file."
+
+# =====================================================================================
+# ====== BUTTON TEXTS (User-facing) ======
+# =====================================================================================
+
+MSG_BUTTON_STREAM_NOW = "🖥️ Stream"
+MSG_BUTTON_DOWNLOAD = "🚀 Download"
+MSG_BUTTON_GET_HELP = "📖 Get Help"
+MSG_BUTTON_CANCEL_BROADCAST = "🛑 Cancel Broadcast"
+MSG_BUTTON_VIEW_PROFILE = "👤 View User Profile"
+MSG_BUTTON_ABOUT = "ℹ️ About Bot"
+MSG_BUTTON_JOIN_CHANNEL = "📢 Join {channel_title}"
+MSG_BUTTON_GITHUB = "🛠️ GitHub"
+MSG_BUTTON_START_CHAT = "📩 Start Chat"
+MSG_BUTTON_CLOSE = "✖ Close"
+
+
+# =====================================================================================
+# ====== COMMAND RESPONSES (User-facing) ======
+# =====================================================================================
+
+MSG_WELCOME = (
+    "🌟 **Welcome, {user_name}!** 🌟\n\n"
+    "I'm **Flash File** ⚡\n"
+    "I generate direct download and streaming links for your files.\n\n"
+    "**How to use:**\n"
+    "1. Send any file to me for private links.\n"
+    "2. In groups, reply to a file with `/link`.\n\n"
+    "» Use `/help` for all commands and detailed information.\n\n"
+    "🚀 Send a file to begin!"
+)
+
+MSG_HELP = (
+    "📘 **Flash File - Help Guide** 📖\n\n"
+    "How to get direct download & streaming links:\n\n"
+    "**🚀 Private Chat (with me):**\n"
+    "> 1. Send me **any file** (document, video, audio, photo, etc.).\n"
+    "> 2. I'll instantly reply with your links! ⚡\n\n"
+    "**👥 Using in Groups:**\n"
+    "> • Reply to any file with `/link`.\n"
+    "> • **Batch Mode:** Reply to the **first** file with `/link <number>` (e.g., `/link 5` for 5 files, up to {max_files}).\n"
+    "> • Bot needs administrator rights in the group to function.\n"
+    "> • Links are posted in the group & sent to you privately.\n\n"
+    "**📢 Using in Channels:**\n"
+    "> • Add me as an administrator with necessary permissions.\n"
+    "> • I can be configured to auto-detect new media files.\n"
+    "> • Inline stream/download buttons can be added to files automatically.\n"
+    "> • Files from banned channels (owner configuration) are rejected.\n"
+    "> • Auto-posting links if the bot has admin privileges with delete rights.\n\n"
+    "**⚙️ Available Commands:**\n"
+    "> `/start` 👋 - Welcome message & quick start information.\n"
+    "> `/help` 📖 - Shows this help message.\n"
+    "> `/link <num>` 🔗 - (Groups) Generate links. \n"
+    "> `/about` ℹ️ - Learn more about me and my features.\n"
+    "> `/ping` 📡 - Check my responsiveness and online status.\n"
+    "> `/dc` 🌍 - View DC information (for yourself, another user, or a file).\n\n"
+    "**💡 Pro Tips:**\n"
+    "> • You can forward files from other chats directly to me.\n"
+    "> • If you encounter a rate limit message, please wait the specified time. ⏳\n"
+    "> • For `/link` in groups to work reliably (and for private link delivery), ensure you've started a private chat with me first.\n"
+    "> • Processing batch files might take a bit longer. Please be patient. 🐌\n\n"
+    "❓ Questions? Please ask in our support group!"
+)
+
+MSG_ABOUT = (
+    "🌟 **About Flash File - File to Link Bot** ℹ️\n\n"
+    "I'm your go-to bot for **instant download & streaming!** ⚡\n\n"
+    "**🚀 Key Features:**\n"
+    "> **Instant Links:** Get your links within seconds.\n"
+    "> **Online Streaming:** Watch videos or listen to audio directly (for supported formats).\n"
+    "> **Universal File Support:** Handles documents, videos, audio, photos, and more.\n"
+    "> **High-Speed Access:** Optimized for fast link generation and file access.\n"
+    "> **Secure & Reliable:** Your files are handled with care during processing.\n"
+    "> **User-Friendly Interface:** Designed for ease of use on any device.\n"
+    "> **Efficient Processing:** Built for speed and reliability.\n"
+    "> **Batch Mode:** Process multiple files at once in groups using `/link <number>`.\n"
+    "> **Versatile Usage:** Works in private chats, groups, and channels (with admin setup).\n\n"
+    "💖 If you find me useful, please consider sharing me with your friends!"
+)
+
+# ------ Ping ------
+MSG_PING_START = "🛰️ **Pinging...** Please wait."
+MSG_PING_RESPONSE = (
+    "☁️ **PONG! Bot is Online!** ⚡\n\n"
+    "> ⏱️ **Ping:** {time_taken_ms:.2f} ms\n"
+    "> 🤖 **Bot Status:** `Active`"
+)
+
+# ------ DC Info ------
+MSG_DC_USER_INFO = (
+    "📍 **Information**\n"
+    "> 👤 **User:** [{user_name}](tg://user?id={user_id})\n"
+    "> 🆔 **User ID:** `{user_id}`\n"
+    "> 🌍 **DC ID:** `{dc_id}`"
+)
+
+MSG_DC_FILE_INFO = (
+    "🗂️ **File Information**\n"
+    ">`{file_name}`\n"
+    "💾 **File Size:** `{file_size}`\n"
+    "📁 **File Type:** `{file_type}`\n"
+    "🌍 **DC ID:** `{dc_id}`"
+)
+
+MSG_DC_UNKNOWN = "Unknown"
+
+# ------ File Link Generation ------
+MSG_DM_SINGLE_PREFIX = "📬 **From {chat_title}**\n"
+MSG_LINKS = (
+    "✨ **Your Links are Ready!** ✨\n\n"
+    "> `{file_name}`\n\n"
+    "📂 **File Size:** `{file_size}`\n\n"
+    "🚀 **Download Link:**\n`{download_link}`\n\n"
+    "🖥️ **Stream Link:**\n`{stream_link}`\n\n"
+    "⌛️ **Note: Links remain active while the bot is running and the file is accessible.**"
+)
+
+# =====================================================================================
+# ====== USER NOTIFICATIONS ======
+# =====================================================================================
+
+MSG_NEW_USER = (
+    "✨ **New User Alert!** ✨\n"
+    "> 👤 **Name:** [{first_name}](tg://user?id={user_id})\n"
+    "> 🆔 **User ID:** `{user_id}`\n\n"
+)
+MSG_COMMUNITY_CHANNEL = "📢 **{channel_title}:** 🔒 Join this channel to use the bot."
+
+# =====================================================================================
+# ====== PROCESSING MESSAGES ======
+# =====================================================================================
+
+# ------ General File Processing ------
+MSG_PROCESSING_REQUEST = "⏳ **Processing your request...**"
+MSG_PROCESSING_FILE = "⏳ **Processing your file...**"
+MSG_NEW_FILE_REQUEST = (
+    "> 👤 **Source:** [{source_info}](tg://user?id={id_})\n"
+    "> 🆔 **ID:** `{id_}`\n\n"
+    "🚀 **Download:** `{online_link}`\n\n"
+    "🖥️ **Stream:** `{stream_link}`"
+)
+
+# ------ Batch Processing ------
+MSG_PROCESSING_BATCH = "♻️ **Processing Batch {batch_number}/{total_batches}** ({file_count} files)"
+MSG_PROCESSING_STATUS = "📊 **Processing Files:** {processed}/{total} complete, {failed} failed"
+MSG_BATCH_LINKS_READY = "🔗 Here are your {count} download links:"
+MSG_DM_BATCH_PREFIX = "📬 **Batch Links from {chat_title}**\n"
+MSG_PROCESSING_RESULT = "✅ **Process Complete:** {processed}/{total} files processed successfully, {failed} failed"
+
+# =====================================================================================
+# ====== BROADCAST MESSAGES ======
+# =====================================================================================
+
+MSG_BROADCAST_START = "📣 **Starting Broadcast...**\n\n> ⏳ Please wait for completion."
+MSG_BROADCAST_COMPLETE = (
+    "📢 **Broadcast Completed Successfully!** 📢\n\n"
+    "⏱️ **Duration:** `{elapsed_time}`\n"
+    "👥 **Total Users:** `{total_users}`\n"
+    "✅ **Successful Deliveries:** `{successes}`\n"
+    "❌ **Failed Deliveries:** `{failures}`\n"
+    "🗑️ **Accounts Removed (Blocked/Deactivated):** `{deleted_accounts}`\n"
+)
+MSG_BROADCAST_CANCEL = "🛑 **Cancelling Broadcast:** `{broadcast_id}`\n\n> ⏳ Stopping operations..."
+MSG_INVALID_BROADCAST_CMD = "Please reply to the message you want to broadcast."
+MSG_BROADCAST_USAGE = (
+    "📣 **Broadcast Command Usage:**\n\n"
+    "`/broadcast` - Broadcast to all users\n"
+    "`/broadcast authorized` - Broadcast to authorized users only\n"
+    "`/broadcast regular` - Broadcast to regular (non-authorized) users only\n\n"
+    "**Note:** Reply to the message you want to broadcast."
+)
+
+# =====================================================================================
+# ====== PERMISSION MESSAGES ======
+# =====================================================================================
+
+MSG_ERROR_UNAUTHORIZED = "You are not authorized to view this information."
+MSG_ERROR_BROADCAST_RESTART = "Please use the /broadcast command to start a new broadcast."
+MSG_ERROR_BROADCAST_INSTRUCTION = "To start a new broadcast, use the /broadcast command and reply to the message you want to broadcast."
+MSG_ERROR_CALLBACK_UNSUPPORTED = "This button is not active or no longer supported."
+
+# =====================================================================================
+# ====== RATE LIMITING MESSAGES ======
+# =====================================================================================
+
+MSG_RATE_LIMIT_QUEUE_PRIORITY = (
+    "⚡ You're in the **Priority Queue!**\n\n"
+    "> ⏳ **Estimated Wait:** `~{wait_estimate} minute{s}`\n"
+    "> 🚀 **Status:** In Queue"
+)
+
+MSG_RATE_LIMIT_QUEUE_REGULAR = (
+    "⏳ **Rate Limit Reached!**\n\n"
+    "> ⌛ **Estimated Wait:** `~{wait_estimate} minute{s1}`\n"
+    "> 📊 **Limit:** `{max_requests} files per {time_window} minute{s2}`\n"
+    "> 🔄 **Status:** In Queue"
+)
+
+MSG_RATE_LIMIT_QUEUE_FULL = (
+    "⚠️ **Service Busy!** The processing queue is currently full.\n\n"
+    "> 🕒 **Please try again in:** `~{wait_estimate} minute{s}`\n"
+    "> 💡 **Tip:** Try again later when system load decreases"
+)
+
+
+# =====================================================================================
+# ====== FILE TYPE DESCRIPTIONS ======
+# =====================================================================================
+MSG_FILE_TYPE_DOCUMENT = "📄 Document"
+MSG_FILE_TYPE_PHOTO = "🖼️ Photo"
+MSG_FILE_TYPE_VIDEO = "🎬 Video"
+MSG_FILE_TYPE_AUDIO = "🎵 Audio"
+MSG_FILE_TYPE_VOICE = "🎤 Voice Message"
+MSG_FILE_TYPE_STICKER = "🎨 Sticker"
+MSG_FILE_TYPE_ANIMATION = "🎞️ Animation (GIF)"
+MSG_FILE_TYPE_VIDEO_NOTE = "📹 Video Note"
+MSG_FILE_TYPE_UNKNOWN = "❓ Unknown File Type"
+
+# =====================================================================================
+# ====== SYSTEM & STATUS MESSAGES ======
+# =====================================================================================
+
+MSG_SYSTEM_STATUS = (
+    "✅ **System Status:** Operational\n\n"
+    "> 🕒 **Uptime:** `{uptime}`\n"
+    "> 🤖 **Bot Instances:** `{active_bots}`\n"
+    "> 📊 **Total Workload:** `{total_workload}`\n\n"
+    "📜 **Workload Distribution:**\n\n"
+    "{workload_items}\n"
+    "> ♻️ **Version:** `{version}`"
+)
+
+# ------ Speedtest Messages ------
+MSG_SPEEDTEST_INIT = "🚀 **Running Speed Test...**"
+MSG_SPEEDTEST_ERROR = "❌ **Speed Test Failed!**\n\n> Unable to complete the speed test. Please try again later."
+MSG_SPEEDTEST_RESULT = (
+    "⚡ **Speed Test Results**\n\n"
+    "**SPEEDTEST INFO:**\n"
+    "> **Download:** `{download_mbps} Mbps` (`{download_bps}/s`)\n"
+    "> **Upload:** `{upload_mbps} Mbps` (`{upload_bps}/s`)\n"
+    "> **Ping:** `{ping} ms`\n"
+    "> **Timestamp:** `{timestamp}`\n"
+    "> **Data Sent:** `{bytes_sent}`\n"
+    "> **Data Received:** `{bytes_received}`\n\n"
+    "**SERVER INFO:**\n"
+    "> **Name:** `{server_name}`\n"
+    "> **Country:** `{server_country}`\n"
+    "> **Sponsor:** `{server_sponsor}`\n"
+    "> **Latency:** `{server_latency} ms`\n"
+    "> **Coordinates:** `{server_lat}, {server_lon}`\n\n"
+    "**CLIENT DETAILS:**\n"
+    "> **IP:** `{client_ip}`\n"
+    "> **Coordinates:** `{client_lat}, {client_lon}`\n"
+    "> **ISP:** `{client_isp}`\n"
+    "> **ISP Rating:** `{client_isprating}`\n"
+    "> **Country:** `{client_country}`"
+)
+MSG_SYSTEM_STATS = (
+    "📊 **System Statistics**\n\n"
+    "> System Uptime: {sys_uptime}\n"
+    "> Bot Uptime: {bot_uptime}\n\n"
+    "⚙️ **Performance:**\n"
+    "> CPU: {cpu_percent}%\n"
+    "> CPU Core: {cpu_cores}\n"
+    "> Frequency: {cpu_freq} GHz\n\n"
+    "💾 **RAM**\n"
+    "> Total: {ram_total}\n"
+    "> Used: {ram_used}\n"
+    "> Free: {ram_free}\n\n"
+    "💽 **Storage:**\n"
+    "> Disk: `{disk_percent}%`\n"
+    "> Total: `{total}`\n"
+    "> Used: `{used}`\n"
+    "> Free: `{free}`\n\n"
+    "📶 **Network:**\n"
+    "> 🔺 Upload: `{upload}`\n"
+    "> 🔻 Download: `{download}`\n"
+)
+
+MSG_DB_STATS = "📊 **Database Statistics**\n\n> 👥 **Total Users:** `{total_users}`"
+
+# Payment & Subscription Messages
+MSG_SUB_PLAN_ACTIVE = (
+    "👑 **Flash File Premium Active**\n\n"
+    "👤 **Account:** `{user_name}` (`{user_id}`)\n"
+    "📅 **Valid Until:** `{expiry_date}`\n"
+    "⏳ **Remaining:** `{remaining_days} days`\n"
+    "⚡ **Tier:** `30-Day Monthly Pass (Unlimited)`\n\n"
+    "✨ You have unlimited streaming & high-speed direct downloads!"
+)
+
+MSG_SUB_PLAN_FREE = (
+    "⚡ **Flash File Premium Access**\n\n"
+    "Unlock unlimited ultra-fast streaming & direct download links:\n\n"
+    "💳 **Monthly Pass:** `₹{price} / 30 Days`\n"
+    "✨ Unlimited high-speed streaming links\n"
+    "⚡ Pure Google Pay UPI integration\n"
+    "📱 Compatible with VLC, MX Player, and Web\n"
+    "🎟 Optional 1-time file passes available\n\n"
+    "🔗 **UPI ID:** `{upi_id}`"
+)
+
+MSG_PAYWALL_GATE = (
+    "🔒 **Flash File Premium Access Required**\n\n"
+    "Direct streaming links for this bot require an active pass:\n\n"
+    "💎 **Monthly Pass:** `₹{price} / 30 Days` (Unlimited)\n"
+    "🎟 **1-Time Pass:** Request temporary access for this file\n\n"
+    "📲 **Pay via UPI:** `{upi_id}`\n"
+    "*(Supports Google Pay, PhonePe, Paytm, BHIM)*"
+)
+
+MSG_PROOF_INSTRUCTION = (
+    "📩 **Submit Payment Proof**\n\n"
+    "Please send your **Transaction ID / UTR Number** or reply to this message with a **screenshot of your payment**.\n\n"
+    "Admin will verify and activate your pass within minutes."
+)
+
+MSG_SUB_APPROVED_USER = (
+    "🎉 **Subscription Activated!**\n\n"
+    "Your **30-Day Monthly Pass** is now active!\n"
+    "📅 **Valid Until:** `{expiry_date}`\n\n"
+    "You can now send any video or document to generate instant stream and download links. Enjoy!"
+)
+
+MSG_TEMP_APPROVED_USER = (
+    "🎟 **Temporary Stream Pass Approved!**\n\n"
+    "You have been granted a **1-time temporary stream pass** (valid for 24 hours).\n\n"
+    "Send or forward your file again to generate your link!"
+)
+
+MSG_SUB_REJECTED_USER = (
+    "❌ **Access Request Not Approved**\n\n"
+    "Your payment proof or pass request could not be verified by admin.\n"
+    "If this is an error or you need help, please reach out to admin."
+)

Thunder/vars.py

@@ -1,111 +1,120 @@
-# Thunder/vars.py
-
-import os
-
-from dotenv import load_dotenv
-from typing import Set, Optional
-from Thunder.utils.logger import logger
-
-load_dotenv("config.env")
-
-def str_to_bool(val: str) -> bool:
-    return val.lower() in ("true", "1", "t", "y", "yes")
-
-def str_to_int_set(val: str) -> Set[int]:
-    if not val:
-        return set()
-    result: Set[int] = set()
-    for x in val.split():
-        try:
-            result.add(int(x))
-        except (TypeError, ValueError):
-            continue
-    return result
-
-
-
-class Var:
-    raw_api_id = os.getenv("API_ID", "0").strip(" '\"")
-    API_ID: int = int(raw_api_id) if raw_api_id.isdigit() else 0
-    API_HASH: str = os.getenv("API_HASH", "").strip(" '\"")
-    BOT_TOKEN: str = os.getenv("BOT_TOKEN", "").strip(" '\"")
-
-    logger.info(
-        "FileToLink Telegram configuration loaded "
-        "(api_id=%s, api_hash=%s, bot_token=%s)",
-        "set" if API_ID else "missing",
-        "set" if API_HASH else "missing",
-        "set" if BOT_TOKEN else "missing",
-    )
-
-    if not all([API_ID, API_HASH, BOT_TOKEN]):
-        logger.critical("Missing required Telegram API configuration")
-        raise ValueError("Missing required Telegram API configuration")
-
-    NAME: str = os.getenv("NAME", "ThunderF2L")
-    SLEEP_THRESHOLD: int = int(os.getenv("SLEEP_THRESHOLD", "600"))
-    WORKERS: int = int(os.getenv("WORKERS", "8"))
-
-    BIN_CHANNEL: int = int(os.getenv("BIN_CHANNEL", "0"))
-
-    if not BIN_CHANNEL:
-        logger.critical("BIN_CHANNEL is required")
-        raise ValueError("BIN_CHANNEL is required")
-
-    PORT: int = int(os.getenv("PORT", "8080"))
-    BIND_ADDRESS: str = os.getenv("BIND_ADDRESS", "0.0.0.0")
-    PING_INTERVAL: int = int(os.getenv("PING_INTERVAL", "840"))
-    NO_PORT: bool = str_to_bool(os.getenv("NO_PORT", "True"))
-
-    OWNER_ID: int = int(os.getenv("OWNER_ID", "0"))
-
-    if not OWNER_ID:
-        logger.warning("WARNING: OWNER_ID is not set. No user will be granted owner access.")
-
-    FQDN: str = os.getenv("FQDN", "") or BIND_ADDRESS
-    HAS_SSL: bool = str_to_bool(os.getenv("HAS_SSL", "True"))
-    PROTOCOL: str = "https" if HAS_SSL else "http"
-    PORT_SEGMENT: str = "" if NO_PORT else f":{PORT}"
-    URL: str = f"{PROTOCOL}://{FQDN}{PORT_SEGMENT}/"
-
-    SET_COMMANDS: bool = str_to_bool(os.getenv("SET_COMMANDS", "True"))
-
-    DATABASE_URL: str = os.getenv("DATABASE_URL", "")
-
-    if not DATABASE_URL:
-        logger.critical("DATABASE_URL is required")
-        raise ValueError("DATABASE_URL is required")
-
-    MAX_BATCH_FILES: int = int(os.getenv("MAX_BATCH_FILES", "50"))
-
-    CHANNEL: bool = str_to_bool(os.getenv("CHANNEL", "False"))
-
-    BANNED_CHANNELS: Set[int] = str_to_int_set(os.getenv("BANNED_CHANNELS", ""))
-
-    MULTI_CLIENT: bool = False
-
-    FORCE_CHANNEL_ID: Optional[int] = None
-
-    force_channel_env = os.getenv("FORCE_CHANNEL_ID", "").strip()
-
-    if force_channel_env:
-        try:
-            FORCE_CHANNEL_ID = int(force_channel_env)
-        except ValueError:
-            logger.warning(f"Invalid FORCE_CHANNEL_ID '{force_channel_env}' in environment; must be an integer.")
-
-    TOKEN_ENABLED: bool = str_to_bool(os.getenv("TOKEN_ENABLED", "False"))
-    TOKEN_TTL_HOURS: int = int(os.getenv("TOKEN_TTL_HOURS", "24"))
-
-    SHORTEN_ENABLED: bool = str_to_bool(os.getenv("SHORTEN_ENABLED", "False"))
-    SHORTEN_MEDIA_LINKS: bool = str_to_bool(os.getenv("SHORTEN_MEDIA_LINKS", "False"))
-    URL_SHORTENER_API_KEY: str = os.getenv("URL_SHORTENER_API_KEY", "")
-    URL_SHORTENER_SITE: str = os.getenv("URL_SHORTENER_SITE", "")
-
-    GLOBAL_RATE_LIMIT: bool = str_to_bool(os.getenv("GLOBAL_RATE_LIMIT", "False"))
-    MAX_GLOBAL_REQUESTS_PER_MINUTE: int = int(os.getenv("MAX_GLOBAL_REQUESTS_PER_MINUTE", "4"))
-
-    RATE_LIMIT_ENABLED: bool = str_to_bool(os.getenv("RATE_LIMIT_ENABLED", "False"))
-    MAX_FILES_PER_PERIOD: int = int(os.getenv("MAX_FILES_PER_PERIOD", "2"))
-    RATE_LIMIT_PERIOD_MINUTES: int = int(os.getenv("RATE_LIMIT_PERIOD_MINUTES", "1"))
-    MAX_QUEUE_SIZE: int = int(os.getenv("MAX_QUEUE_SIZE", "100"))
+# Thunder/vars.py
+
+import os
+
+from dotenv import load_dotenv
+from typing import Set, Optional
+from Thunder.utils.logger import logger
+
+load_dotenv("config.env")
+
+def str_to_bool(val: str) -> bool:
+    return val.lower() in ("true", "1", "t", "y", "yes")
+
+def str_to_int_set(val: str) -> Set[int]:
+    if not val:
+        return set()
+    result: Set[int] = set()
+    for x in val.split():
+        try:
+            result.add(int(x))
+        except (TypeError, ValueError):
+            continue
+    return result
+
+
+
+class Var:
+    raw_api_id = os.getenv("API_ID", "0").strip(" '\"")
+    API_ID: int = int(raw_api_id) if raw_api_id.isdigit() else 0
+    API_HASH: str = os.getenv("API_HASH", "").strip(" '\"")
+    BOT_TOKEN: str = os.getenv("BOT_TOKEN", "").strip(" '\"")
+
+    logger.info(
+        "FileToLink Telegram configuration loaded "
+        "(api_id=%s, api_hash=%s, bot_token=%s)",
+        "set" if API_ID else "missing",
+        "set" if API_HASH else "missing",
+        "set" if BOT_TOKEN else "missing",
+    )
+
+    if not all([API_ID, API_HASH, BOT_TOKEN]):
+        logger.critical("Missing required Telegram API configuration")
+        raise ValueError("Missing required Telegram API configuration")
+
+    NAME: str = os.getenv("NAME", "ThunderF2L")
+    SLEEP_THRESHOLD: int = int(os.getenv("SLEEP_THRESHOLD", "600"))
+    WORKERS: int = int(os.getenv("WORKERS", "8"))
+
+    BIN_CHANNEL: int = int(os.getenv("BIN_CHANNEL", "0"))
+
+    if not BIN_CHANNEL:
+        logger.critical("BIN_CHANNEL is required")
+        raise ValueError("BIN_CHANNEL is required")
+
+    PORT: int = int(os.getenv("PORT", "8080"))
+    BIND_ADDRESS: str = os.getenv("BIND_ADDRESS", "0.0.0.0")
+    PING_INTERVAL: int = int(os.getenv("PING_INTERVAL", "840"))
+    NO_PORT: bool = str_to_bool(os.getenv("NO_PORT", "True"))
+
+
+    raw_owner_id = os.getenv("OWNER_ID", "0").strip(" '\"")
+    OWNER_ID: int = int(raw_owner_id) if (raw_owner_id.isdigit() or (raw_owner_id.startswith("-") and raw_owner_id[1:].isdigit())) else 0
+    if not OWNER_ID:
+        logger.warning("WARNING: OWNER_ID is not set. No user will be granted owner access.")
+
+    FQDN: str = os.getenv("FQDN", "") or BIND_ADDRESS
+    HAS_SSL: bool = str_to_bool(os.getenv("HAS_SSL", "True"))
+    PROTOCOL: str = "https" if HAS_SSL else "http"
+    PORT_SEGMENT: str = "" if NO_PORT else f":{PORT}"
+    URL: str = f"{PROTOCOL}://{FQDN}{PORT_SEGMENT}/"
+
+    SET_COMMANDS: bool = str_to_bool(os.getenv("SET_COMMANDS", "True"))
+
+    DATABASE_URL: str = os.getenv("DATABASE_URL", "")
+
+    if not DATABASE_URL:
+        logger.critical("DATABASE_URL is required")
+        raise ValueError("DATABASE_URL is required")
+
+    MAX_BATCH_FILES: int = int(os.getenv("MAX_BATCH_FILES", "50"))
+
+    CHANNEL: bool = str_to_bool(os.getenv("CHANNEL", "False"))
+
+    BANNED_CHANNELS: Set[int] = str_to_int_set(os.getenv("BANNED_CHANNELS", ""))
+
+    MULTI_CLIENT: bool = False
+
+    FORCE_CHANNEL_ID: Optional[int] = None
+
+    force_channel_env = os.getenv("FORCE_CHANNEL_ID", "").strip()
+
+    if force_channel_env:
+        try:
+            FORCE_CHANNEL_ID = int(force_channel_env)
+        except ValueError:
+            logger.warning(f"Invalid FORCE_CHANNEL_ID '{force_channel_env}' in environment; must be an integer.")
+
+    TOKEN_ENABLED: bool = str_to_bool(os.getenv("TOKEN_ENABLED", "False"))
+    TOKEN_TTL_HOURS: int = int(os.getenv("TOKEN_TTL_HOURS", "24"))
+
+    SHORTEN_ENABLED: bool = str_to_bool(os.getenv("SHORTEN_ENABLED", "False"))
+    SHORTEN_MEDIA_LINKS: bool = str_to_bool(os.getenv("SHORTEN_MEDIA_LINKS", "False"))
+    URL_SHORTENER_API_KEY: str = os.getenv("URL_SHORTENER_API_KEY", "")
+    URL_SHORTENER_SITE: str = os.getenv("URL_SHORTENER_SITE", "")
+
+    GLOBAL_RATE_LIMIT: bool = str_to_bool(os.getenv("GLOBAL_RATE_LIMIT", "False"))
+    MAX_GLOBAL_REQUESTS_PER_MINUTE: int = int(os.getenv("MAX_GLOBAL_REQUESTS_PER_MINUTE", "4"))
+
+    RATE_LIMIT_ENABLED: bool = str_to_bool(os.getenv("RATE_LIMIT_ENABLED", "False"))
+    MAX_FILES_PER_PERIOD: int = int(os.getenv("MAX_FILES_PER_PERIOD", "2"))
+    RATE_LIMIT_PERIOD_MINUTES: int = int(os.getenv("RATE_LIMIT_PERIOD_MINUTES", "1"))
+    MAX_QUEUE_SIZE: int = int(os.getenv("MAX_QUEUE_SIZE", "100"))
+
+    # Subscription & Payment Gateway (Dormant by default)
+    PAYMENT_ENABLED: bool = str_to_bool(os.getenv("PAYMENT", os.getenv("Payment", "False")))
+    SUB_PRICE: int = int(os.getenv("SUB_PRICE", "10"))
+    SUB_DURATION_DAYS: int = int(os.getenv("SUB_DURATION_DAYS", "30"))
+    UPI_ID: str = os.getenv("UPI_ID", "jishnupg2005-2@okaxis").strip()
+    UPI_NAME: str = os.getenv("UPI_NAME", "Flash File").strip()
+    ADMIN_CHANNEL: int = int(os.getenv("ADMIN_CHANNEL", "0"))