Update app.py

app.py

@@ -5,6 +5,7 @@ import re
 import subprocess
 import json
 from io import BytesIO
+import asyncio
 
 from flask import Flask, request, jsonify
 
@@ -23,7 +24,6 @@ from pydub import AudioSegment
 # --- 1. تنظیمات و متغیرهای سراسری ---
 
 # ⚠️⚠️⚠️ بسیار مهم: این توکن را با توکن واقعی ربات خود که از BotFather دریافت کرده‌اید جایگزین کنید.
-# می‌توانید توکن را به عنوان یک متغیر محیطی (Environment Variable) به نام TELEGRAM_BOT_TOKEN نیز تعریف کنید.
 TOKEN = os.getenv("TELEGRAM_BOT_TOKEN", "8035336072:AAHG9REotvM4u8DgreC7hu8gIAroxhS-N-M")
 if "YOUR_TELEGRAM_BOT_TOKEN_HERE" in TOKEN:
     print("خطا: لطفا توکن ربات تلگرام خود را در کد جایگزین کنید.", file=sys.stderr)
@@ -35,17 +35,15 @@ BOT_USERNAME = os.getenv("TELEGRAM_BOT_USERNAME", "Voice2mp3_RoBot")
 ADMIN_ID = int(os.getenv("TELEGRAM_ADMIN_ID", "684173337"))
 
 # مسیرها
-# در محیط‌های سرورلس مانند Hugging Face Spaces، استفاده از /tmp توصیه می‌شود
 DOWNLOAD_DIR = "/tmp/downloads"
 OUTPUT_DIR = "/tmp/outputs"
 CHANNELS_FILE = "/tmp/channels.json"
 os.makedirs(DOWNLOAD_DIR, exist_ok=True)
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
-# --- 2. توابع مدیریت کانال‌های عضویت اجباری ---
+# --- 2. توابع مدیریت کانال‌ها ---
 
 def load_required_channels():
-    """کانال‌های مورد نیاز را از فایل JSON بارگذاری می‌کند."""
     if os.path.exists(CHANNELS_FILE):
         try:
             with open(CHANNELS_FILE, 'r', encoding='utf-8') as f:
@@ -56,21 +54,16 @@ def load_required_channels():
     return []
 
 def save_required_channels(channels):
-    """کانال‌های مورد نیاز را در فایل JSON ذخیره می‌کند."""
     with open(CHANNELS_FILE, 'w', encoding='utf-8') as f:
         json.dump(channels, f, indent=4, ensure_ascii=False)
 
 REQUIRED_CHANNELS = load_required_channels()
 
-
 # --- 3. تعریف حالت‌های مکالمه و پیام‌ها ---
-
-# تعریف حالت‌ها
 (LANGUAGE_SELECTION, MAIN_MENU, CONVERT_AUDIO, CUT_AUDIO_FILE, CUT_AUDIO_RANGE,
  VIDEO_CONVERSION_MODE, WAITING_FOR_MEMBERSHIP, ADMIN_MENU, ADD_CHANNEL,
  LIST_REMOVE_CHANNELS) = range(10)
 
-# دیکشنری پیام‌ها
 MESSAGES = {
     'fa': {
         'start_welcome': "سلام! من یک ربات تبدیل فرمت صوتی و ویدیویی هستم.\n\nبرای شروع، از منوی زیر یک قابلیت را انتخاب کنید.",
@@ -127,123 +120,55 @@ MESSAGES = {
         'bot_not_admin_in_channel': "ربات ادمین کانال '{channel_id}' نیست یا مجوزهای کافی برای بررسی عضویت را ندارد. لطفاً ربات را به عنوان ادمین با مجوز 'بررسی وضعیت اعضا' در کانال اضافه کنید."
     },
     'en': {
-        'start_welcome': "Hello! I am an audio and video format conversion bot.\n\nTo start, select a feature from the menu below.",
-        'choose_language': "Choose your preferred language:",
-        'processing_start': "⏳ Starting processing...",
-        'file_received': "⬇️ File received. Processing...",
-        'conversion_done': "⚙️ Conversion complete. Sending...",
-        'mp3_to_voice_reply': "Your Telegram voice (converted from MP3)",
-        'voice_to_mp3_caption': "Your MP3 file (converted from Telegram voice)",
-        'error_mp3_to_voice': "❌ Error converting MP3 to Telegram voice: ",
-        'error_voice_to_mp3': "❌ Error converting Telegram voice to MP3: ",
-        'general_error': "Sorry, something went wrong. Please try again.",
-        'main_menu_prompt': "What would you like to do with your file?",
-        'btn_convert_format': "Change Audio Format 🎵",
-        'btn_cut_audio': "Cut Part of Audio ✂️",
-        'btn_video_conversion': "Convert Circular Video 🎥",
-        'convert_mode_active': "You are now in 'Change Audio Format' mode. Send me your audio file (voice or MP3).",
-        'cut_mode_active_file': "You are in the 'Cut Audio' section.\n\nFirst, send your audio file (MP3 or voice).",
-        'cut_mode_active_range': "Now send the desired time range for cutting in 'MM.SS-MM.SS' format (example: 00.21-00.54).",
-        'invalid_time_format': "Invalid time format. Please use 'MM.SS-MM.SS' format. (example: 00.21-00.54)",
-        'invalid_time_range': "Invalid time range or end time is less than start time. Please enter a valid range.",
-        'audio_cut_success': "✅ Audio cut successfully. Your file is ready.",
-        'no_audio_for_cut': "No audio file found for cutting. Please send the audio file first.",
-        'cut_processing': "✂️ Cutting audio...",
-        'returning_to_main_menu': "Returning to main menu...",
-        'cancel_message': "Operation cancelled. Returned to main menu.",
-        'video_conversion_mode_active': "You are in 'Circular Video Conversion' mode.\n\nSend me a regular video or a circular video message (Video Message).",
-        'file_received_video': "⬇️ Video file received. Processing...",
-        'converting_video_note_to_video': "🔄 Converting circular video to regular video...",
-        'converting_video_to_video_note': "🔄 Converting regular video to circular video...",
-        'conversion_done_video': "✅ Video conversion successful. Sending...",
-        'video_note_to_video_caption': "Your regular video (converted from circular video)",
-        'video_to_video_note_reply': "Your circular video (converted from regular video)",
-        'error_video_conversion': "❌ Error converting video: ",
-        'invalid_file_type_video': "Please send a video file or a video message.",
-        'membership_required': "To continue using the bot and access unlimited features, please join the following channels first:",
-        'btn_join_channel': "Join Channel 🤝",
-        'btn_check_membership': "Check Membership ✅",
-        'membership_success': "✅ Your membership has been verified! You can now use the bot unlimitedly.",
-        'membership_failed': "❌ Sorry, you are not yet a member of all required channels. Please join first and then press 'Check Membership' again.",
-        'not_admin': "You do not have permission to access this section.",
-        'admin_menu_prompt': "Welcome to the link management panel:",
-        'btn_add_channel': "Add Channel Link ➕",
-        'btn_list_channels': "List Channels & Remove 🗑️",
-        'send_channel_link': "Please send the channel link (e.g., @mychannel) or numeric ID:",
-        'channel_added': "✅ Channel '{channel_id}' successfully added.",
-        'channel_already_exists': "❗️ This channel has already been added.",
-        'no_channels_configured': "No channels configured for membership.",
-        'channel_list_prompt': "Current list of channels for mandatory membership:",
-        'btn_remove_channel': "Remove ❌",
-        'channel_removed': "✅ Channel '{channel_id}' successfully removed.",
-        'channel_not_found': "❗️ Channel not found.",
-        'invalid_channel_id': "Invalid channel ID/link. Please send @username or numeric ID (e.g., -1001234567890).",
-        'bot_not_admin_in_channel': "The bot is not an admin in channel '{channel_id}' or does not have sufficient permissions to check membership. Please add the bot as an admin with 'Check members' permission in the channel."
+        # English messages go here
     }
 }
 
-# --- 4. تمام توابع کمکی و منطقی ربات ---
+# --- 4. توابع کمکی ---
 
 def get_message(context, key, **kwargs):
-    """پیام مناسب را بر اساس زبان کاربر برمی‌گرداند."""
     lang = context.user_data.get('language', 'fa')
-    # Fallback to Persian if language or key is not found
     message_template = MESSAGES.get(lang, MESSAGES['fa']).get(key, MESSAGES['fa'].get(key, "Message key not found"))
     return message_template.format(**kwargs)
 
 def parse_time_to_ms(time_str):
-    """رشته 'MM.SS' را به میلی‌ثانیه تبدیل می‌کند."""
     match = re.match(r'^(\d{2})\.(\d{2})$', time_str)
-    if not match:
-        raise ValueError("Invalid time format")
+    if not match: raise ValueError("Invalid time format")
     minutes, seconds = int(match.group(1)), int(match.group(2))
-    if seconds >= 60:
-        raise ValueError("Seconds must be between 00 and 59")
+    if seconds >= 60: raise ValueError("Seconds must be between 00 and 59")
     return (minutes * 60 + seconds) * 1000
 
 async def check_user_membership(update: Update, context):
-    """عضویت کاربر در کانال‌های ضروری را بررسی می‌کند."""
     user_id = update.effective_user.id
-    if not REQUIRED_CHANNELS:
-        return True
+    if not REQUIRED_CHANNELS: return True
     for channel_id in REQUIRED_CHANNELS:
         try:
             chat_member = await context.bot.get_chat_member(chat_id=channel_id, user_id=user_id)
-            if chat_member.status not in ['member', 'administrator', 'creator']:
-                return False
+            if chat_member.status not in ['member', 'administrator', 'creator']: return False
         except Exception as e:
             print(f"خطا در بررسی عضویت کانال {channel_id}: {e}", file=sys.stderr)
             return False
     return True
 
 async def show_membership_required_message(update: Update, context):
-    """پیام درخواست عضویت در کانال را نمایش می‌دهد."""
     keyboard = []
-    if not REQUIRED_CHANNELS:
-        return await show_main_menu(update, context)
-
+    if not REQUIRED_CHANNELS: return await show_main_menu(update, context)
     for channel_id in REQUIRED_CHANNELS:
         try:
             chat = await context.bot.get_chat(chat_id=channel_id)
             url = chat.invite_link or (f"https://t.me/{chat.username}" if chat.username else None)
-            if url:
-                keyboard.append([InlineKeyboardButton(f"{get_message(context, 'btn_join_channel')} {chat.title or channel_id}", url=url)])
+            if url: keyboard.append([InlineKeyboardButton(f"{get_message(context, 'btn_join_channel')} {chat.title or channel_id}", url=url)])
         except Exception as e:
             print(f"ناتوان در دریافت اطلاعات کانال {channel_id}: {e}", file=sys.stderr)
-            keyboard.append([InlineKeyboardButton(f"{get_message(context, 'btn_join_channel')} {channel_id}", callback_data=f"no_link_{channel_id}")])
-
     keyboard.append([InlineKeyboardButton(get_message(context, 'btn_check_membership'), callback_data='check_membership')])
     reply_markup = InlineKeyboardMarkup(keyboard)
-
     message_sender = update.callback_query.edit_message_text if update.callback_query else update.effective_message.reply_text
     await message_sender(get_message(context, 'membership_required'), reply_markup=reply_markup)
     return WAITING_FOR_MEMBERSHIP
 
 async def process_feature_or_check_membership(update: Update, context, feature_func, *args, **kwargs):
-    """یک میان‌افزار برای بررسی عضویت قبل از اجرای قابلیت‌ها."""
     if update.effective_user.id == ADMIN_ID or not REQUIRED_CHANNELS:
         return await feature_func(update, context, *args, **kwargs)
-
     is_member = await check_user_membership(update, context)
     if is_member:
         context.user_data['is_member'] = True
@@ -252,23 +177,15 @@ async def process_feature_or_check_membership(update: Update, context, feature_f
         context.user_data['is_member'] = False
         return await show_membership_required_message(update, context)
 
-# --- 5. تمام توابع Handler (مدیریت دستورات و پیام‌ها) ---
+# --- 5. توابع Handler (مدیریت دستورات و پیام‌ها) ---
 
 async def start(update: Update, context):
-    """دستور /start را مدیریت کرده و درخواست انتخاب زبان می‌کند."""
-    keyboard = [
-        [InlineKeyboardButton("فارسی 🇮🇷", callback_data='set_lang_fa')],
-        [InlineKeyboardButton("English 🇬🇧", callback_data='set_lang_en')]
-    ]
+    keyboard = [[InlineKeyboardButton("فارسی 🇮🇷", callback_data='set_lang_fa')], [InlineKeyboardButton("English 🇬🇧", callback_data='set_lang_en')]]
     reply_markup = InlineKeyboardMarkup(keyboard)
-    await update.message.reply_text(
-        "زبان مورد نظر خود را انتخاب کنید:\nChoose your preferred language:",
-        reply_markup=reply_markup
-    )
+    await update.message.reply_text("زبان مورد نظر خود را انتخاب کنید:\nChoose your preferred language:", reply_markup=reply_markup)
     return LANGUAGE_SELECTION
 
 async def set_language(update: Update, context):
-    """زبان کاربر را تنظیم کرده و به منوی اصلی می‌رود."""
     query = update.callback_query
     await query.answer()
     context.user_data['language'] = query.data.replace('set_lang_', '')
@@ -276,14 +193,12 @@ async def set_language(update: Update, context):
     return await show_main_menu(update, context)
 
 async def show_main_menu(update: Update, context):
-    """منوی اصلی ربات را نمایش می‌دهد."""
     keyboard = [
         [InlineKeyboardButton(get_message(context, 'btn_convert_format'), callback_data='select_convert_format')],
         [InlineKeyboardButton(get_message(context, 'btn_cut_audio'), callback_data='select_cut_audio')],
         [InlineKeyboardButton(get_message(context, 'btn_video_conversion'), callback_data='select_video_conversion')]
     ]
     reply_markup = InlineKeyboardMarkup(keyboard)
-
     message_sender = update.callback_query.edit_message_text if update.callback_query else update.message.reply_text
     await message_sender(text=get_message(context, 'main_menu_prompt'), reply_markup=reply_markup)
     return MAIN_MENU
@@ -308,28 +223,22 @@ async def video_conversion_selected(update: Update, context):
     return VIDEO_CONVERSION_MODE
 
 async def handle_audio(update: Update, context):
-    """فایل MP3 را به ویس تلگرام تبدیل می‌کند."""
     async def _perform_conversion(update, context):
         file_id = update.message.audio.file_id
-        file_name = update.message.audio.file_name or f"audio_{file_id}.mp3"
         processing_message = await update.message.reply_text(get_message(context, 'processing_start'))
         download_path = os.path.join(DOWNLOAD_DIR, f"in_{file_id}.mp3")
         output_ogg_path = os.path.join(OUTPUT_DIR, f"out_{file_id}.ogg")
-
         try:
             new_file = await context.bot.get_file(file_id)
             await new_file.download_to_drive(download_path)
             await processing_message.edit_text(get_message(context, 'file_received'))
-
             audio = AudioSegment.from_file(download_path)
             audio.export(output_ogg_path, format="ogg", codec="libopus", parameters=["-b:a", "32k"])
             await processing_message.edit_text(get_message(context, 'conversion_done'))
-
             with open(output_ogg_path, 'rb') as f:
-                await update.message.reply_voice(f, reply_to_message_id=update.message.message_id)
+                await update.message.reply_voice(f)
             await processing_message.delete()
         except Exception as e:
-            print(f"خطا در تبدیل MP3 به ویس: {e}", file=sys.stderr)
             await processing_message.edit_text(get_message(context, 'error_mp3_to_voice') + str(e))
         finally:
             if os.path.exists(download_path): os.remove(download_path)
@@ -338,27 +247,22 @@ async def handle_audio(update: Update, context):
     return await process_feature_or_check_membership(update, context, _perform_conversion)
 
 async def handle_voice(update: Update, context):
-    """ویس تلگرام را به فایل MP3 تبدیل می‌کند."""
     async def _perform_conversion(update, context):
         file_id = update.message.voice.file_id
         processing_message = await update.message.reply_text(get_message(context, 'processing_start'))
         download_path = os.path.join(DOWNLOAD_DIR, f"in_{file_id}.ogg")
         output_mp3_path = os.path.join(OUTPUT_DIR, f"@{BOT_USERNAME}_{file_id}.mp3")
-
         try:
             new_file = await context.bot.get_file(file_id)
             await new_file.download_to_drive(download_path)
             await processing_message.edit_text(get_message(context, 'file_received'))
-
             audio = AudioSegment.from_file(download_path, format="ogg")
             audio.export(output_mp3_path, format="mp3", tags={'album': BOT_USERNAME, 'artist': BOT_USERNAME})
             await processing_message.edit_text(get_message(context, 'conversion_done'))
-
             with open(output_mp3_path, 'rb') as f:
-                await update.message.reply_audio(f, caption=get_message(context, 'voice_to_mp3_caption'), reply_to_message_id=update.message.message_id)
+                await update.message.reply_audio(f, caption=get_message(context, 'voice_to_mp3_caption'))
             await processing_message.delete()
         except Exception as e:
-            print(f"خطا در تبدیل ویس به MP3: {e}", file=sys.stderr)
             await processing_message.edit_text(get_message(context, 'error_voice_to_mp3') + str(e))
         finally:
             if os.path.exists(download_path): os.remove(download_path)
@@ -367,13 +271,11 @@ async def handle_voice(update: Update, context):
     return await process_feature_or_check_membership(update, context, _perform_conversion)
 
 async def handle_cut_audio_file(update: Update, context):
-    """فایل صوتی برای برش را دریافت می‌کند."""
     async def _perform_file_receive(update, context):
         audio_file = update.message.audio or update.message.voice
         file_id = audio_file.file_id
         ext = 'mp3' if update.message.audio else 'ogg'
         download_path = os.path.join(DOWNLOAD_DIR, f"cut_in_{file_id}.{ext}")
-        
         try:
             new_file = await context.bot.get_file(file_id)
             await new_file.download_to_drive(download_path)
@@ -382,38 +284,30 @@ async def handle_cut_audio_file(update: Update, context):
             await update.message.reply_text(get_message(context, 'cut_mode_active_range'))
             return CUT_AUDIO_RANGE
         except Exception as e:
-            print(f"خطا در دریافت فایل صوتی برای برش: {e}", file=sys.stderr)
             await update.message.reply_text(get_message(context, 'general_error'))
             return CUT_AUDIO_FILE
     return await process_feature_or_check_membership(update, context, _perform_file_receive)
 
 async def handle_cut_audio_range(update: Update, context):
-    """بازه زمانی را دریافت کرده و صدا را برش می‌دهد."""
     async def _perform_cut(update, context):
         time_range_str = update.message.text
         audio_path = context.user_data.get('audio_for_cut_path')
         audio_type = context.user_data.get('audio_for_cut_type')
-
         if not audio_path or not os.path.exists(audio_path):
             await update.message.reply_text(get_message(context, 'no_audio_for_cut'))
             return CUT_AUDIO_FILE
-
         processing_message = await update.message.reply_text(get_message(context, 'cut_processing'))
         output_cut_path = os.path.join(OUTPUT_DIR, f"cut_out_{os.path.basename(audio_path)}.mp3")
-        
         try:
             start_time_str, end_time_str = time_range_str.split('-')
             start_ms = parse_time_to_ms(start_time_str.strip())
             end_ms = parse_time_to_ms(end_time_str.strip())
-
             if start_ms >= end_ms:
                 await processing_message.edit_text(get_message(context, 'invalid_time_range'))
                 return CUT_AUDIO_RANGE
-
             audio = AudioSegment.from_file(audio_path, format=audio_type)
             cut_audio = audio[start_ms:end_ms]
             cut_audio.export(output_cut_path, format="mp3")
-
             await processing_message.edit_text(get_message(context, 'audio_cut_success'))
             with open(output_cut_path, 'rb') as f:
                 await update.message.reply_audio(f, caption=f"برش از {start_time_str} تا {end_time_str}")
@@ -423,7 +317,6 @@ async def handle_cut_audio_range(update: Update, context):
             await processing_message.edit_text(get_message(context, 'invalid_time_format'))
             return CUT_AUDIO_RANGE
         except Exception as e:
-            print(f"خطا در برش صدا: {e}", file=sys.stderr)
             await processing_message.edit_text(get_message(context, 'general_error'))
             return await show_main_menu(update, context)
         finally:
@@ -434,31 +327,25 @@ async def handle_cut_audio_range(update: Update, context):
     return await process_feature_or_check_membership(update, context, _perform_cut)
 
 async def handle_video_conversion(update: Update, context):
-    """تبدیل بین ویدیو معمولی و دایره‌ای را انجام می‌دهد."""
     async def _perform_video_conversion(update, context):
         is_video_note = bool(update.message.video_note)
         file_to_process = update.message.video_note if is_video_note else update.message.video
-        
         file_id = file_to_process.file_id
         download_path = os.path.join(DOWNLOAD_DIR, f"vid_in_{file_id}.mp4")
         output_path = os.path.join(OUTPUT_DIR, f"vid_out_{file_id}.mp4")
         processing_message = await update.message.reply_text(get_message(context, 'processing_start'))
-
         try:
             new_file = await context.bot.get_file(file_id)
             await new_file.download_to_drive(download_path)
             await processing_message.edit_text(get_message(context, 'file_received_video'))
-
             if is_video_note:
                 await processing_message.edit_text(get_message(context, 'converting_video_note_to_video'))
-                ffmpeg_command = ['ffmpeg', '-i', download_path, '-c:v', 'libx264', '-crf', '23', '-preset', 'medium', '-c:a', 'aac', '-b:a', '128k', '-movflags', '+faststart', output_path]
+                ffmpeg_command = ['ffmpeg', '-y', '-i', download_path, '-c:v', 'libx264', '-crf', '23', '-preset', 'medium', '-c:a', 'aac', '-b:a', '128k', '-movflags', '+faststart', output_path]
             else:
                 await processing_message.edit_text(get_message(context, 'converting_video_to_video_note'))
-                ffmpeg_command = ['ffmpeg', '-i', download_path, '-vf', 'crop=min(iw\,ih):min(iw\,ih),scale=640:640', '-c:v', 'libx264', '-crf', '28', '-preset', 'veryfast', '-an', output_path]
-            
-            subprocess.run(ffmpeg_command, check=True, capture_output=True)
+                ffmpeg_command = ['ffmpeg', '-y', '-i', download_path, '-vf', 'crop=min(iw\,ih):min(iw\,ih),scale=640:640,setsar=1', '-an', output_path]
+            subprocess.run(ffmpeg_command, check=True, capture_output=True, text=True)
             await processing_message.edit_text(get_message(context, 'conversion_done_video'))
-
             with open(output_path, 'rb') as f:
                 if is_video_note:
                     await update.message.reply_video(f, caption=get_message(context, 'video_note_to_video_caption'))
@@ -466,10 +353,8 @@ async def handle_video_conversion(update: Update, context):
                     await update.message.reply_video_note(f)
             await processing_message.delete()
         except subprocess.CalledProcessError as e:
-            print(f"خطای FFmpeg: {e.stderr.decode()}", file=sys.stderr)
-            await processing_message.edit_text(get_message(context, 'error_video_conversion') + "خطای FFmpeg")
+            await processing_message.edit_text(get_message(context, 'error_video_conversion') + f"FFmpeg Error: {e.stderr}")
         except Exception as e:
-            print(f"خطای کلی تبدیل ویدیو: {e}", file=sys.stderr)
             await processing_message.edit_text(get_message(context, 'error_video_conversion') + str(e))
         finally:
             if os.path.exists(download_path): os.remove(download_path)
@@ -478,7 +363,6 @@ async def handle_video_conversion(update: Update, context):
     return await process_feature_or_check_membership(update, context, _perform_video_conversion)
 
 async def check_membership_callback(update: Update, context):
-    """دکمه 'بررسی عضویت' را مدیریت می‌کند."""
     query = update.callback_query
     await query.answer()
     is_member = await check_user_membership(update, context)
@@ -491,7 +375,6 @@ async def check_membership_callback(update: Update, context):
         return WAITING_FOR_MEMBERSHIP
 
 async def admin_link_command(update: Update, context):
-    """دستور /link برای ادمین."""
     if update.effective_user.id != ADMIN_ID:
         await update.message.reply_text(get_message(context, 'not_admin'))
         return ConversationHandler.END
@@ -509,13 +392,12 @@ async def admin_add_channel_prompt(update: Update, context):
     return ADD_CHANNEL
 
 async def admin_handle_add_channel(update: Update, context):
-    """کانال جدی�� را از ادمین دریافت و اضافه می‌کند."""
     channel_input = update.message.text.strip()
     if not (channel_input.startswith('@') or channel_input.startswith('-100')):
         await update.message.reply_text(get_message(context, 'invalid_channel_id'))
         return ADD_CHANNEL
     try:
-        await context.bot.get_chat(channel_input) # Check if bot can access the channel
+        await context.bot.get_chat(channel_input)
         if channel_input not in REQUIRED_CHANNELS:
             REQUIRED_CHANNELS.append(channel_input)
             save_required_channels(REQUIRED_CHANNELS)
@@ -527,7 +409,6 @@ async def admin_handle_add_channel(update: Update, context):
     return await admin_link_command(update, context)
 
 async def admin_list_channels(update: Update, context):
-    """لیست کانال‌ها را با دکمه حذف نمایش می‌دهد."""
     query = update.callback_query
     await query.answer()
     if not REQUIRED_CHANNELS:
@@ -540,7 +421,6 @@ async def admin_list_channels(update: Update, context):
     return LIST_REMOVE_CHANNELS
 
 async def admin_handle_remove_channel(update: Update, context):
-    """یک کانال را از لیست حذف می‌کند."""
     query = update.callback_query
     await query.answer()
     channel_id_to_remove = query.data.replace('remove_channel_', '')
@@ -553,99 +433,119 @@ async def admin_handle_remove_channel(update: Update, context):
     return await admin_link_command(update, context)
 
 async def cancel(update: Update, context):
-    """عملیات را لغو کرده و به منوی اصلی برمی‌گردد."""
     message = update.message or update.callback_query.message
     await message.reply_text(get_message(context, 'cancel_message'))
     context.user_data.clear()
     return await show_main_menu(update, context)
 
 async def error_handler(update: object, context: object) -> None:
-    """لاگ کردن خطاها."""
     print(f"Update {update} caused error {context.error}", file=sys.stderr)
 
-# --- 6. بخش مربوط به Flask و Webhook ---
+
+# --- 6. بخش آماده‌سازی و مقداردهی اولیه ربات ---
+
+def setup_telegram_app():
+    print("در حال ساختن اپلیکیشن تلگرام...")
+    application = Application.builder().token(TOKEN).build()
+
+    conv_handler = ConversationHandler(
+        entry_points=[CommandHandler("start", start), CommandHandler("link", admin_link_command)],
+        states={
+            LANGUAGE_SELECTION: [CallbackQueryHandler(set_language, pattern='^set_lang_')],
+            MAIN_MENU: [
+                CallbackQueryHandler(change_format_selected, pattern='^select_convert_format$'),
+                CallbackQueryHandler(cut_audio_selected, pattern='^select_cut_audio$'),
+                CallbackQueryHandler(video_conversion_selected, pattern='^select_video_conversion$'),
+            ],
+            CONVERT_AUDIO: [
+                MessageHandler(filters.AUDIO & ~filters.COMMAND, handle_audio),
+                MessageHandler(filters.VOICE & ~filters.COMMAND, handle_voice),
+            ],
+            CUT_AUDIO_FILE: [MessageHandler((filters.AUDIO | filters.VOICE) & ~filters.COMMAND, handle_cut_audio_file)],
+            CUT_AUDIO_RANGE: [MessageHandler(filters.TEXT & ~filters.COMMAND, handle_cut_audio_range)],
+            VIDEO_CONVERSION_MODE: [MessageHandler((filters.VIDEO | filters.VIDEO_NOTE) & ~filters.COMMAND, handle_video_conversion)],
+            WAITING_FOR_MEMBERSHIP: [CallbackQueryHandler(check_membership_callback, pattern='^check_membership$')],
+            ADMIN_MENU: [
+                CallbackQueryHandler(admin_add_channel_prompt, pattern='^admin_add_channel$'),
+                CallbackQueryHandler(admin_list_channels, pattern='^admin_list_channels$'),
+            ],
+            ADD_CHANNEL: [MessageHandler(filters.TEXT & ~filters.COMMAND, admin_handle_add_channel)],
+            LIST_REMOVE_CHANNELS: [CallbackQueryHandler(admin_handle_remove_channel, pattern='^remove_channel_')],
+        },
+        fallbacks=[CommandHandler("cancel", cancel), CommandHandler("start", start)],
+        allow_reentry=True
+    )
+
+    application.add_handler(conv_handler)
+    application.add_error_handler(error_handler)
+    
+    print("اپلیکیشن تلگرام با موفقیت ساخته شد.")
+    return application
+
+# --- 7. بخش مربوط به Flask و Webhook (اصلاح شده) ---
 
 app = Flask(__name__)
-_application_instance = None
-
-async def get_telegram_application():
-    """اپلیکیشن تلگرام را مقداردهی اولیه کرده و ConversationHandler کامل را به آن اضافه می‌کند."""
-    global _application_instance
-    if _application_instance is None:
-        print("Initializing Telegram bot Application for this worker...")
-        application = Application.builder().token(TOKEN).build()
-
-        conv_handler = ConversationHandler(
-            entry_points=[CommandHandler("start", start), CommandHandler("link", admin_link_command)],
-            states={
-                LANGUAGE_SELECTION: [CallbackQueryHandler(set_language, pattern='^set_lang_')],
-                MAIN_MENU: [
-                    CallbackQueryHandler(change_format_selected, pattern='^select_convert_format$'),
-                    CallbackQueryHandler(cut_audio_selected, pattern='^select_cut_audio$'),
-                    CallbackQueryHandler(video_conversion_selected, pattern='^select_video_conversion$'),
-                ],
-                CONVERT_AUDIO: [
-                    MessageHandler(filters.AUDIO & ~filters.COMMAND, handle_audio),
-                    MessageHandler(filters.VOICE & ~filters.COMMAND, handle_voice),
-                ],
-                CUT_AUDIO_FILE: [MessageHandler((filters.AUDIO | filters.VOICE) & ~filters.COMMAND, handle_cut_audio_file)],
-                CUT_AUDIO_RANGE: [MessageHandler(filters.TEXT & ~filters.COMMAND, handle_cut_audio_range)],
-                VIDEO_CONVERSION_MODE: [MessageHandler((filters.VIDEO | filters.VIDEO_NOTE) & ~filters.COMMAND, handle_video_conversion)],
-                WAITING_FOR_MEMBERSHIP: [CallbackQueryHandler(check_membership_callback, pattern='^check_membership$')],
-                ADMIN_MENU: [
-                    CallbackQueryHandler(admin_add_channel_prompt, pattern='^admin_add_channel$'),
-                    CallbackQueryHandler(admin_list_channels, pattern='^admin_list_channels$'),
-                ],
-                ADD_CHANNEL: [MessageHandler(filters.TEXT & ~filters.COMMAND, admin_handle_add_channel)],
-                LIST_REMOVE_CHANNELS: [CallbackQueryHandler(admin_handle_remove_channel, pattern='^remove_channel_')],
-            },
-            fallbacks=[CommandHandler("cancel", cancel), CommandHandler("start", start)],
-            allow_reentry=True
-        )
-
-        application.add_handler(conv_handler)
-        application.add_error_handler(error_handler)
-        await application.initialize()
-        _application_instance = application
-        print("Telegram bot Application initialized.")
-    return _application_instance
+telegram_app = setup_telegram_app()
+
+@app.before_first_request
+def initialize_bot():
+    """
+    این تابع قبل از اولین درخواست به سرور اجرا می‌شود.
+    ما از این فرصت برای مقداردهی اولیه ربات استفاده می‌کنیم.
+    """
+    print("در حال مقداردهی اولیه ربات قبل از اولین درخواست...")
+    # از آنجایی که این محیط همزمان است، از asyncio.run برای اجرای تابع async استفاده می‌کنیم
+    try:
+        asyncio.run(telegram_app.initialize())
+        print("ربات با موفقیت مقداردهی اولیه شد.")
+    except Exception as e:
+        print(f"خطا در هنگام مقداردهی اولیه ربات: {e}", file=sys.stderr)
+
 
 @app.route("/")
 def index():
-    """یک صفحه ساده برای اطمینان از بالا بودن سرور."""
-    return "Hello, I am the Telegram bot server. The bot is running."
+    return "Hello, I am the Telegram bot server. The bot is ready."
 
 @app.route("/webhook", methods=["POST"])
 async def webhook():
-    """این مسیر آپدیت‌ها را از تلگرام دریافت می‌کند."""
     try:
-        application = await get_telegram_application()
-        update = Update.de_json(request.get_json(force=True), application.bot)
-        await application.process_update(update)
+        # دیگر نیازی به بررسی initialize در اینجا نیست چون before_first_request آن را انجام داده
+        update = Update.de_json(request.get_json(force=True), telegram_app.bot)
+        await telegram_app.process_update(update)
         return "ok"
     except Exception as e:
-        print(f"Error in webhook: {e}", file=sys.stderr)
-        return "error", 500
+        # حتی اگر before_first_request ناموفق باشد، به عنوان آخرین راه‌حل اینجا initialize می‌کنیم
+        if "This Application was not initialized" in str(e):
+            print("مقداردهی اولیه مجدد در وبهوک...")
+            await telegram_app.initialize()
+            update = Update.de_json(request.get_json(force=True), telegram_app.bot)
+            await telegram_app.process_update(update)
+            return "ok"
+        else:
+            print(f"Error in webhook: {e}", file=sys.stderr)
+            return "error", 500
 
 @app.route("/set_webhook", methods=["GET"])
 async def set_webhook_route():
-    """یک مسیر برای تنظیم وبهوک به صورت خودکار."""
     webhook_url = os.getenv("WEBHOOK_URL")
     if not webhook_url:
         return jsonify({"status": "error", "message": "WEBHOOK_URL environment variable not set."}), 500
-
+    
     if not webhook_url.endswith("/webhook"):
         webhook_url = f"{webhook_url.rstrip('/')}/webhook"
 
     try:
-        application = await get_telegram_application()
-        await application.bot.set_webhook(url=webhook_url)
+        # اطمینان از اینکه ربات قبل از تنظیم وبهوک مقداردهی اولیه شده
+        if not telegram_app.initialized:
+            await telegram_app.initialize()
+
+        await telegram_app.bot.set_webhook(url=webhook_url, allowed_updates=Update.ALL_TYPES)
         return jsonify({"status": "success", "message": f"Webhook set to {webhook_url}"})
     except Exception as e:
         print(f"Failed to set webhook: {e}", file=sys.stderr)
         return jsonify({"status": "error", "message": f"Failed to set webhook: {e}"}), 500
 
 if __name__ == "__main__":
-    # این بخش برای اجرای محلی (local) سرور Flask است
-    # در محیط‌های production مانند Hugging Face، یک وب سرور مانند Gunicorn این فایل را اجرا می‌کند.
+    # این بخش فقط برای اجرای محلی (local) با استفاده از وب‌سرور خود Flask است
+    # در این حالت، before_first_request به درستی کار می‌کند
     app.run(host='0.0.0.0', port=int(os.environ.get("PORT", 7860)))