Update app.py

app.py

@@ -7,54 +7,70 @@ import json
 from io import BytesIO
 
 from flask import Flask, request, jsonify
-from a2wsgi import ASGIMiddleware  # ->
-# واسط برای سازگاری با سرور
 
-from telegram import Update, InputFile, InlineKeyboardButton, InlineKeyboardMarkup, error as telegram_error
+from telegram import Update, InputFile, InlineKeyboardButton, InlineKeyboardMarkup
 from telegram.ext import (
     Application,
     CommandHandler,
     MessageHandler,
     CallbackQueryHandler,
     filters,
-    ConversationHandler,
-    ContextTypes,
+    ConversationHandler
 )
 from telegram.constants import ParseMode
 from pydub import AudioSegment
 
-# --- Environment Variables ---
-# These should be set as "Secrets" in your Hugging Face Space settings
-TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
-if not TOKEN:
-    print("Error: TELEGRAM_BOT_TOKEN environment variable not set.", file=sys.stderr)
+# --- 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)
     sys.exit(1)
 
+# نام کاربری ربات و آیدی ادمین
 BOT_USERNAME = os.getenv("TELEGRAM_BOT_USERNAME", "Voice2mp3_RoBot")
-# Ensure ADMIN_ID is an integer
-try:
-    ADMIN_ID = int(os.getenv("TELEGRAM_ADMIN_ID", "0"))
-except ValueError:
-    print("Error: TELEGRAM_ADMIN_ID is not a valid integer.", file=sys.stderr)
-    ADMIN_ID = 0
-
-if ADMIN_ID == 0:
-    print("Warning: TELEGRAM_ADMIN_ID not set or is 0. Admin features will be disabled.", file=sys.stderr)
-
-# --- Directories and Files ---
-# Use the /tmp directory as it is writable in Hugging Face Spaces
+# ⚠️⚠️⚠️ این را به آیدی عددی تلگرام خودتان تغییر دهید.
+ADMIN_ID = int(os.getenv("TELEGRAM_ADMIN_ID", "684173337"))
+
+# مسیرها
+# در محیط‌های سرورلس مانند Hugging Face Spaces، استفاده از /tmp توصیه می‌شود
 DOWNLOAD_DIR = "/tmp/downloads"
 OUTPUT_DIR = "/tmp/outputs"
-CHANNELS_FILE = "channels.json"
+CHANNELS_FILE = "/tmp/channels.json"
 os.makedirs(DOWNLOAD_DIR, exist_ok=True)
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
-# --- Conversation States ---
-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)
+# --- 2. توابع مدیریت کانال‌های عضویت اجباری ---
 
-# --- Multi-language Messages ---
+def load_required_channels():
+    """کانال‌های مورد نیاز را از فایل JSON بارگذاری می‌کند."""
+    if os.path.exists(CHANNELS_FILE):
+        try:
+            with open(CHANNELS_FILE, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except json.JSONDecodeError:
+            print(f"خطا در خواندن فایل JSON کانال‌ها: {CHANNELS_FILE}", file=sys.stderr)
+            return []
+    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برای شروع، از منوی زیر یک قابلیت را انتخاب کنید.",
@@ -108,7 +124,7 @@ MESSAGES = {
         'channel_removed': "✅ کانال '{channel_id}' با موفقیت حذف شد.",
         'channel_not_found': "❗️ کانال مورد نظر یافت نشد.",
         'invalid_channel_id': "آیدی/لینک کانال نامعتبر است. لطفاً @username یا آیدی عددی (مانند -1001234567890) را ارسال کنید.",
-        'bot_not_admin_in_channel': "ربات ادمین کانال '{channel_id}' نیست یا مجوزهای کافی برای بررسی عضویت را ندارد. لطفاً ربات را به عنوان ادمین با مجوز 'دعوت کاربران از طریق لینک' در کانال اضافه کنید."
+        '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.",
@@ -162,35 +178,22 @@ MESSAGES = {
         '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 'Invite Users via Link' permission in the channel."
+        '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."
     }
 }
 
+# --- 4. تمام توابع کمکی و منطقی ربات ---
 
-# --- Channel Management Functions ---
-def load_required_channels():
-    if os.path.exists(CHANNELS_FILE):
-        try:
-            with open(CHANNELS_FILE, 'r', encoding='utf-8') as f:
-                return json.load(f)
-        except json.JSONDecodeError:
-            print(f"Error decoding JSON from {CHANNELS_FILE}.", file=sys.stderr)
-    return []
-
-def save_required_channels(channels):
-    with open(CHANNELS_FILE, 'w', encoding='utf-8') as f:
-        json.dump(channels, f, indent=4, ensure_ascii=False)
-
-REQUIRED_CHANNELS = load_required_channels()
-
-# --- Helper Functions ---
-def get_message(context: ContextTypes.DEFAULT_TYPE, key: str, **kwargs) -> str:
+def get_message(context, key, **kwargs):
+    """پیام مناسب را بر اساس زبان کاربر برمی‌گرداند."""
     lang = context.user_data.get('language', 'fa')
-    message_template = MESSAGES.get(lang, {}).get(key, MESSAGES['fa'][key])
+    # 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: str) -> int:
-    match = re.match(r'^(\d{1,2})\.(\d{2})$', time_str)
+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")
     minutes, seconds = int(match.group(1)), int(match.group(2))
@@ -198,77 +201,61 @@ def parse_time_to_ms(time_str: str) -> int:
         raise ValueError("Seconds must be between 00 and 59")
     return (minutes * 60 + seconds) * 1000
 
-
-# --- Membership Check ---
-async def check_user_membership(update: Update, context: ContextTypes.DEFAULT_TYPE) -> bool:
+async def check_user_membership(update: Update, context):
+    """عضویت کاربر در کانال‌های ضروری را بررسی می‌کند."""
     user_id = update.effective_user.id
     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
-        except telegram_error.BadRequest as e:
-            # This can happen if channel_id is invalid or bot is not in the channel
-            print(f"Error checking membership for channel {channel_id}: {e}", file=sys.stderr)
-            return False
         except Exception as e:
-            print(f"Unexpected error checking membership for {channel_id}: {e}", file=sys.stderr)
+            print(f"خطا در بررسی عضویت کانال {channel_id}: {e}", file=sys.stderr)
             return False
     return True
 
-async def show_membership_required_message(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+async def show_membership_required_message(update: Update, context):
+    """پیام درخواست عضویت در کانال را نمایش می‌دهد."""
     keyboard = []
     if not REQUIRED_CHANNELS:
         return await show_main_menu(update, context)
 
     for channel_id in REQUIRED_CHANNELS:
         try:
-            # Using a generic URL for @username and assuming invite link for others
-            if str(channel_id).startswith('@'):
-                url = f"https://t.me/{channel_id.lstrip('@')}"
-                title = channel_id
-            else:
-                chat = await context.bot.get_chat(chat_id=channel_id)
-                url = chat.invite_link or f"https://t.me/c/{str(channel_id).replace('-100', '')}"
-                title = chat.title or channel_id
-            keyboard.append([InlineKeyboardButton(f"{get_message(context, 'btn_join_channel')} {title}", url=url)])
+            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)])
         except Exception as e:
-            print(f"Could not get chat info for {channel_id}: {e}", file=sys.stderr)
-            # Fallback button
-            keyboard.append([InlineKeyboardButton(f"{get_message(context, 'btn_join_channel')} {channel_id}", url=f"https://t.me/{str(channel_id).lstrip('@')}")])
+            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_target = update.callback_query.message if update.callback_query else update.effective_message
-    await message_target.reply_text(
-        get_message(context, 'membership_required'),
-        reply_markup=reply_markup
-    )
+    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: ContextTypes.DEFAULT_TYPE, feature_func, *args, **kwargs):
-    user_id = update.effective_user.id
-    # Grant access if user is admin, or no channels are required
-    if user_id == ADMIN_ID or not REQUIRED_CHANNELS:
+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)
 
-    # Allow one-time use before checking membership
-    if context.user_data.get('used_bot_once', False):
-        is_member = await check_user_membership(update, context)
-        if not is_member:
-            return await show_membership_required_message(update, context)
+    is_member = await check_user_membership(update, context)
+    if is_member:
+        context.user_data['is_member'] = True
+        return await feature_func(update, context, *args, **kwargs)
     else:
-        context.user_data['used_bot_once'] = True
-    
-    return await feature_func(update, context, *args, **kwargs)
+        context.user_data['is_member'] = False
+        return await show_membership_required_message(update, context)
 
+# --- 5. تمام توابع Handler (مدیریت دستورات و پیام‌ها) ---
 
-# --- Core Bot Handlers ---
-async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+async def start(update: Update, context):
+    """دستور /start را مدیریت کرده و درخواست انتخاب زبان می‌کند."""
     keyboard = [
         [InlineKeyboardButton("فارسی 🇮🇷", callback_data='set_lang_fa')],
         [InlineKeyboardButton("English 🇬🇧", callback_data='set_lang_en')]
@@ -280,354 +267,316 @@ async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
     )
     return LANGUAGE_SELECTION
 
-async def set_language(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+async def set_language(update: Update, context):
+    """زبان کاربر را تنظیم کرده و به منوی اصلی می‌رود."""
     query = update.callback_query
     await query.answer()
-    lang_code = query.data.replace('set_lang_', '')
-    context.user_data['language'] = lang_code
+    context.user_data['language'] = query.data.replace('set_lang_', '')
     await query.edit_message_text(text=get_message(context, 'start_welcome'))
     return await show_main_menu(update, context)
 
-async def show_main_menu(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+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)
-    
-    query = update.callback_query
-    message_target = query.message if query else update.effective_message
-    
-    if query:
-        await query.edit_message_text(text=get_message(context, 'main_menu_prompt'), reply_markup=reply_markup)
-    else:
-        await message_target.reply_text(text=get_message(context, 'main_menu_prompt'), reply_markup=reply_markup)
 
+    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
 
-async def change_format_selected(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+async def change_format_selected(update: Update, context):
     query = update.callback_query
     await query.answer()
     await query.edit_message_text(text=get_message(context, 'convert_mode_active'))
     return CONVERT_AUDIO
 
-async def cut_audio_selected(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+async def cut_audio_selected(update: Update, context):
     query = update.callback_query
     await query.answer()
     await query.edit_message_text(text=get_message(context, 'cut_mode_active_file'))
     context.user_data.pop('audio_for_cut_path', None)
     return CUT_AUDIO_FILE
 
-async def video_conversion_selected(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+async def video_conversion_selected(update: Update, context):
     query = update.callback_query
     await query.answer()
     await query.edit_message_text(text=get_message(context, 'video_conversion_mode_active'))
     return VIDEO_CONVERSION_MODE
 
-# --- File Processing Handlers (Wrapped with membership check) ---
-
-async def handle_audio(update: Update, context: ContextTypes.DEFAULT_TYPE):
+async def handle_audio(update: Update, context):
+    """فایل MP3 را به ویس تلگرام تبدیل می‌کند."""
     async def _perform_conversion(update, context):
-        file = update.message.audio
-        processing_msg = await update.message.reply_text(get_message(context, 'file_received'))
-        
-        download_path = os.path.join(DOWNLOAD_DIR, f"{file.file_id}.mp3")
-        output_ogg_path = os.path.join(OUTPUT_DIR, f"{file.file_id}.ogg")
+        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:
-            tg_file = await context.bot.get_file(file.file_id)
-            await tg_file.download_to_drive(download_path)
-            
-            await processing_msg.edit_text(get_message(context, 'conversion_done'))
+            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"])
-            
-            with open(output_ogg_path, 'rb') as voice_file:
-                await update.message.reply_voice(voice_file, reply_to_message_id=update.message.message_id)
+            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 processing_message.delete()
         except Exception as e:
-            print(f"Error converting MP3 to voice: {e}", file=sys.stderr)
-            await processing_msg.edit_text(get_message(context, 'error_mp3_to_voice') + str(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)
             if os.path.exists(output_ogg_path): os.remove(output_ogg_path)
-            await processing_msg.delete()
         return CONVERT_AUDIO
     return await process_feature_or_check_membership(update, context, _perform_conversion)
 
-async def handle_voice(update: Update, context: ContextTypes.DEFAULT_TYPE):
+async def handle_voice(update: Update, context):
+    """ویس تلگرام را به فایل MP3 تبدیل می‌کند."""
     async def _perform_conversion(update, context):
-        file = update.message.voice
-        processing_msg = await update.message.reply_text(get_message(context, 'file_received'))
-
-        download_path = os.path.join(DOWNLOAD_DIR, f"{file.file_id}.ogg")
-        output_mp3_path = os.path.join(OUTPUT_DIR, f"@{BOT_USERNAME}_{file.file_id}.mp3")
+        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:
-            tg_file = await context.bot.get_file(file.file_id)
-            await tg_file.download_to_drive(download_path)
+            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'))
 
-            await processing_msg.edit_text(get_message(context, 'conversion_done'))
-            audio = AudioSegment.from_file(download_path)
-            audio.export(output_mp3_path, format="mp3", tags={'artist': f'@{BOT_USERNAME}'})
-
-            with open(output_mp3_path, 'rb') as audio_file:
-                await update.message.reply_audio(
-                    audio_file, 
-                    caption=get_message(context, 'voice_to_mp3_caption'),
-                    reply_to_message_id=update.message.message_id
-                )
+            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 processing_message.delete()
         except Exception as e:
-            print(f"Error converting voice to MP3: {e}", file=sys.stderr)
-            await processing_msg.edit_text(get_message(context, 'error_voice_to_mp3') + str(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)
             if os.path.exists(output_mp3_path): os.remove(output_mp3_path)
-            await processing_msg.delete()
         return CONVERT_AUDIO
     return await process_feature_or_check_membership(update, context, _perform_conversion)
 
-async def handle_cut_audio_file(update: Update, context: ContextTypes.DEFAULT_TYPE):
+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
-        if not audio_file:
-            await update.message.reply_text(get_message(context, 'no_audio_for_cut'))
-            return CUT_AUDIO_FILE
-
-        file_ext = 'mp3' if update.message.audio else 'ogg'
-        download_path = os.path.join(DOWNLOAD_DIR, f"cut_{audio_file.file_id}.{file_ext}")
+        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:
-            tg_file = await context.bot.get_file(audio_file.file_id)
-            await tg_file.download_to_drive(download_path)
+            new_file = await context.bot.get_file(file_id)
+            await new_file.download_to_drive(download_path)
             context.user_data['audio_for_cut_path'] = download_path
-            context.user_data['audio_for_cut_type'] = file_ext
+            context.user_data['audio_for_cut_type'] = ext
             await update.message.reply_text(get_message(context, 'cut_mode_active_range'))
             return CUT_AUDIO_RANGE
         except Exception as e:
-            print(f"Error downloading audio for cutting: {e}", file=sys.stderr)
+            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: ContextTypes.DEFAULT_TYPE):
+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_msg = await update.message.reply_text(get_message(context, 'cut_processing'))
-        output_cut_path = None
+        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:
-            time_range_str = update.message.text
-            start_str, end_str = time_range_str.split('-')
-            start_ms = parse_time_to_ms(start_str.strip())
-            end_ms = parse_time_to_ms(end_str.strip())
+            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_msg.edit_text(get_message(context, 'invalid_time_range'))
+                await processing_message.edit_text(get_message(context, 'invalid_time_range'))
                 return CUT_AUDIO_RANGE
 
-            audio = AudioSegment.from_file(audio_path, format=context.user_data['audio_for_cut_type'])
+            audio = AudioSegment.from_file(audio_path, format=audio_type)
             cut_audio = audio[start_ms:end_ms]
-            
-            output_cut_path = os.path.join(OUTPUT_DIR, f"cut_output_{os.path.basename(audio_path)}")
             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_str.strip()} تا {end_str.strip()}")
-            
-            await processing_msg.delete()
+                await update.message.reply_audio(f, caption=f"برش از {start_time_str} تا {end_time_str}")
+            await processing_message.delete()
             return await show_main_menu(update, context)
-
-        except (ValueError, IndexError):
-            await processing_msg.edit_text(get_message(context, 'invalid_time_format'))
+        except ValueError:
+            await processing_message.edit_text(get_message(context, 'invalid_time_format'))
             return CUT_AUDIO_RANGE
         except Exception as e:
-            print(f"Error cutting audio: {e}", file=sys.stderr)
-            await processing_msg.edit_text(get_message(context, 'general_error'))
+            print(f"خطا در برش صدا: {e}", file=sys.stderr)
+            await processing_message.edit_text(get_message(context, 'general_error'))
             return await show_main_menu(update, context)
         finally:
             if os.path.exists(audio_path): os.remove(audio_path)
-            if output_cut_path and os.path.exists(output_cut_path): os.remove(output_cut_path)
+            if os.path.exists(output_cut_path): os.remove(output_cut_path)
             context.user_data.pop('audio_for_cut_path', None)
             context.user_data.pop('audio_for_cut_type', None)
-
     return await process_feature_or_check_membership(update, context, _perform_cut)
 
-async def handle_video_conversion(update: Update, context: ContextTypes.DEFAULT_TYPE):
+async def handle_video_conversion(update: Update, context):
+    """تبدیل بین ویدیو معمولی و دایره‌ای را انجام می‌دهد."""
     async def _perform_video_conversion(update, context):
         is_video_note = bool(update.message.video_note)
-        file = update.message.video_note if is_video_note else update.message.video
-        if not file:
-            await update.message.reply_text(get_message(context, 'invalid_file_type_video'))
-            return VIDEO_CONVERSION_MODE
-
-        processing_msg = await update.message.reply_text(get_message(context, 'file_received_video'))
-        download_path = os.path.join(DOWNLOAD_DIR, f"{file.file_id}.mp4")
-        output_path = os.path.join(OUTPUT_DIR, f"converted_{file.file_id}.mp4")
+        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:
-            tg_file = await context.bot.get_file(file.file_id)
-            await tg_file.download_to_drive(download_path)
+            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_msg.edit_text(get_message(context, 'converting_video_note_to_video'))
-                # Just send as a regular video
-                with open(download_path, 'rb') as video_file:
-                    await update.message.reply_video(video_file, caption=get_message(context, 'video_note_to_video_caption'))
+                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]
             else:
-                await processing_msg.edit_text(get_message(context, 'converting_video_to_video_note'))
-                # Crop to square, scale, and send as video note
-                ffmpeg_command = [
-                    'ffmpeg', '-i', download_path,
-                    '-vf', 'crop=min(iw\\,ih):min(iw\\,ih),scale=360:360',
-                    '-c:v', 'libx264', '-crf', '28', '-preset', 'veryfast',
-                    '-c:a', 'aac', '-b:a', '64k',
-                    '-movflags', '+faststart', output_path, '-y'
-                ]
-                subprocess.run(ffmpeg_command, check=True, capture_output=True, text=True)
-                with open(output_path, 'rb') as video_file:
-                    await update.message.reply_video_note(video_file)
-
+                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)
+            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'))
+                else:
+                    await update.message.reply_video_note(f)
+            await processing_message.delete()
         except subprocess.CalledProcessError as e:
-            print(f"FFmpeg Error: {e.stderr}", file=sys.stderr)
-            await processing_msg.edit_text(get_message(context, 'error_video_conversion') + "FFmpeg Error")
+            print(f"خطای FFmpeg: {e.stderr.decode()}", file=sys.stderr)
+            await processing_message.edit_text(get_message(context, 'error_video_conversion') + "خطای FFmpeg")
         except Exception as e:
-            print(f"Video conversion error: {e}", file=sys.stderr)
-            await processing_msg.edit_text(get_message(context, 'error_video_conversion') + str(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)
             if os.path.exists(output_path): os.remove(output_path)
-            await processing_msg.delete()
         return VIDEO_CONVERSION_MODE
     return await process_feature_or_check_membership(update, context, _perform_video_conversion)
 
-async def check_membership_callback(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+async def check_membership_callback(update: Update, context):
+    """دکمه 'بررسی عضویت' را مدیریت می‌کند."""
     query = update.callback_query
     await query.answer()
     is_member = await check_user_membership(update, context)
     if is_member:
-        context.user_data['used_bot_once'] = True # Mark as verified
+        context.user_data['is_member'] = True
         await query.edit_message_text(get_message(context, 'membership_success'))
         return await show_main_menu(update, context)
     else:
         await query.answer(get_message(context, 'membership_failed'), show_alert=True)
         return WAITING_FOR_MEMBERSHIP
 
-
-# --- Admin Handlers ---
-async def admin_link_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
+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
-
     keyboard = [
         [InlineKeyboardButton(get_message(context, 'btn_add_channel'), callback_data='admin_add_channel')],
         [InlineKeyboardButton(get_message(context, 'btn_list_channels'), callback_data='admin_list_channels')]
     ]
-    reply_markup = InlineKeyboardMarkup(keyboard)
-    await update.message.reply_text(get_message(context, 'admin_menu_prompt'), reply_markup=reply_markup)
+    await update.message.reply_text(get_message(context, 'admin_menu_prompt'), reply_markup=InlineKeyboardMarkup(keyboard))
     return ADMIN_MENU
 
-async def admin_add_channel_prompt(update: Update, context: ContextTypes.DEFAULT_TYPE):
+async def admin_add_channel_prompt(update: Update, context):
     query = update.callback_query
     await query.answer()
     await query.edit_message_text(get_message(context, 'send_channel_link'))
     return ADD_CHANNEL
 
-async def admin_handle_add_channel(update: Update, context: ContextTypes.DEFAULT_TYPE):
+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:
-        # Check if bot can get chat info, which implies it's in the channel
-        await context.bot.get_chat(channel_input)
+        await context.bot.get_chat(channel_input) # Check if bot can access the channel
+        if channel_input not in REQUIRED_CHANNELS:
+            REQUIRED_CHANNELS.append(channel_input)
+            save_required_channels(REQUIRED_CHANNELS)
+            await update.message.reply_text(get_message(context, 'channel_added', channel_id=channel_input))
+        else:
+            await update.message.reply_text(get_message(context, 'channel_already_exists'))
     except Exception as e:
-        print(f"Error checking bot status in channel {channel_input}: {e}", file=sys.stderr)
-        await update.message.reply_text(get_message(context, 'bot_not_admin_in_channel', channel_id=channel_input))
-        return ADD_CHANNEL
-
-    if channel_input not in REQUIRED_CHANNELS:
-        REQUIRED_CHANNELS.append(channel_input)
-        save_required_channels(REQUIRED_CHANNELS)
-        await update.message.reply_text(get_message(context, 'channel_added', channel_id=channel_input))
-    else:
-        await update.message.reply_text(get_message(context, 'channel_already_exists'))
-    
-    # Go back to admin menu
-    await admin_link_command(update, context)
-    return ADMIN_MENU
+        await update.message.reply_text(get_message(context, 'bot_not_admin_in_channel', channel_id=channel_input) + f"\nError: {e}")
+    return await admin_link_command(update, context)
 
-async def admin_list_channels(update: Update, context: ContextTypes.DEFAULT_TYPE):
+async def admin_list_channels(update: Update, context):
+    """لیست کانال‌ها را با دکمه حذف نمایش می‌دهد."""
     query = update.callback_query
     await query.answer()
     if not REQUIRED_CHANNELS:
         await query.edit_message_text(get_message(context, 'no_channels_configured'))
         return ADMIN_MENU
-
     keyboard = []
     for channel_id in REQUIRED_CHANNELS:
         keyboard.append([InlineKeyboardButton(f"{get_message(context, 'btn_remove_channel')} {channel_id}", callback_data=f'remove_channel_{channel_id}')])
-    
-    reply_markup = InlineKeyboardMarkup(keyboard)
-    await query.edit_message_text(get_message(context, 'channel_list_prompt'), reply_markup=reply_markup)
+    await query.edit_message_text(get_message(context, 'channel_list_prompt'), reply_markup=InlineKeyboardMarkup(keyboard))
     return LIST_REMOVE_CHANNELS
 
-async def admin_handle_remove_channel(update: Update, context: ContextTypes.DEFAULT_TYPE):
+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_', '')
-
     if channel_id_to_remove in REQUIRED_CHANNELS:
         REQUIRED_CHANNELS.remove(channel_id_to_remove)
         save_required_channels(REQUIRED_CHANNELS)
         await query.edit_message_text(get_message(context, 'channel_removed', channel_id=channel_id_to_remove))
     else:
         await query.edit_message_text(get_message(context, 'channel_not_found'))
-    
-    # Go back to admin menu by showing the updated list
-    await admin_list_channels(update, context)
-    return LIST_REMOVE_CHANNELS
-
-async def cancel(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
-    # Clean up temp files if any
-    audio_path = context.user_data.pop('audio_for_cut_path', None)
-    if audio_path and os.path.exists(audio_path):
-        os.remove(audio_path)
-    context.user_data.pop('audio_for_cut_type', None)
+    return await admin_link_command(update, context)
 
-    await update.effective_message.reply_text(get_message(context, 'cancel_message'))
+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: ContextTypes.DEFAULT_TYPE) -> None:
+async def error_handler(update: object, context: object) -> None:
+    """لاگ کردن خطاها."""
     print(f"Update {update} caused error {context.error}", file=sys.stderr)
-    if isinstance(update, Update) and update.effective_message:
-         await update.effective_message.reply_text(get_message(context, 'general_error'))
 
+# --- 6. بخش مربوط به Flask و Webhook ---
 
-# --- Flask & Telegram Application Setup ---
 app = Flask(__name__)
-app = ASGIMiddleware(app)  # Wrap the Flask app with the ASGI middleware
-
 _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...")
-        builder = Application.builder().token(TOKEN)
-        _app = builder.build()
+        application = Application.builder().token(TOKEN).build()
 
         conv_handler = ConversationHandler(
-            entry_points=[
-                CommandHandler("start", start),
-                CommandHandler("link", admin_link_command)
-            ],
+            entry_points=[CommandHandler("start", start), CommandHandler("link", admin_link_command)],
             states={
                 LANGUAGE_SELECTION: [CallbackQueryHandler(set_language, pattern='^set_lang_')],
                 MAIN_MENU: [
@@ -636,12 +585,12 @@ async def get_telegram_application():
                     CallbackQueryHandler(video_conversion_selected, pattern='^select_video_conversion$'),
                 ],
                 CONVERT_AUDIO: [
-                    MessageHandler(filters.AUDIO, handle_audio),
-                    MessageHandler(filters.VOICE, handle_voice),
+                    MessageHandler(filters.AUDIO & ~filters.COMMAND, handle_audio),
+                    MessageHandler(filters.VOICE & ~filters.COMMAND, handle_voice),
                 ],
-                CUT_AUDIO_FILE: [MessageHandler(filters.AUDIO | filters.VOICE, handle_cut_audio_file)],
+                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, handle_video_conversion)],
+                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$'),
@@ -650,57 +599,53 @@ async def get_telegram_application():
                 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),
-            ],
+            fallbacks=[CommandHandler("cancel", cancel), CommandHandler("start", start)],
             allow_reentry=True
         )
 
-        _app.add_handler(conv_handler)
-        _app.add_error_handler(error_handler)
-        
-        await _app.initialize()
-        _application_instance = _app
+        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
 
-# --- Flask Web Routes ---
 @app.route("/")
-async def index():
-    return jsonify({"status": "ok", "message": "Telegram bot is running."})
+def index():
+    """یک صفحه ساده برای اطمینان از بالا بودن سرور."""
+    return "Hello, I am the Telegram bot server. The bot is running."
 
 @app.route("/webhook", methods=["POST"])
 async def webhook():
-    application = await get_telegram_application()
-    update_data = await request.get_json()
-    update = Update.de_json(update_data, application.bot)
-    await application.process_update(update)
-    return "ok"
+    """این مسیر آپدیت‌ها را از تلگرام دریافت می‌کند."""
+    try:
+        application = await get_telegram_application()
+        update = Update.de_json(request.get_json(force=True), application.bot)
+        await application.process_update(update)
+        return "ok"
+    except Exception as e:
+        print(f"Error in webhook: {e}", file=sys.stderr)
+        return "error", 500
 
 @app.route("/set_webhook", methods=["GET"])
 async def set_webhook_route():
-    application = await get_telegram_application()
-    # WEBHOOK_URL should be set as a Secret in Hugging Face
+    """یک مسیر برای تنظیم وبهوک به صورت خودکار."""
     webhook_url = os.getenv("WEBHOOK_URL")
     if not webhook_url:
-        return jsonify({"status": "error", "message": "WEBHOOK_URL not set."}), 500
-    
+        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"
+        webhook_url = f"{webhook_url.rstrip('/')}/webhook"
 
     try:
+        application = await get_telegram_application()
         await application.bot.set_webhook(url=webhook_url)
-        print(f"Webhook successfully set to {webhook_url}")
         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
 
-# This part is for local testing and will not be used on Hugging Face Spaces
 if __name__ == "__main__":
-    import asyncio
-    print("Starting Flask app in local mode...")
-    # This initializes the bot for local run, but on HF it's done via the web route
-    asyncio.run(get_telegram_application()) 
-    app.run(host='0.0.0.0', port=int(os.environ.get("PORT", 7860)))
+    # این بخش برای اجرای محلی (local) سرور Flask است
+    # در محیط‌های production مانند Hugging Face، یک وب سرور مانند Gunicorn این فایل را اجرا می‌کند.
+    app.run(host='0.0.0.0', port=int(os.environ.get("PORT", 7860)))