Update app.py

app.py

@@ -4,10 +4,8 @@ import re
 import subprocess
 import json
 from io import BytesIO
-
 from flask import Flask, request, jsonify
-
-from telegram import Update, InputFile, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram import Update, InputFile, InlineKeyboardButton, InlineKeyboardMarkup, BotCommand
 from telegram.ext import (
     Application,
     CommandHandler,
@@ -16,8 +14,9 @@ from telegram.ext import (
     filters,
     ConversationHandler
 )
-from telegram.constants import ParseMode
+from telegram.constants import ParseMode, ChatMemberStatus
 from pydub import AudioSegment
+from pydub.silence import split_on_silence # Optional: for advanced audio processing if needed
 
 # Environment variables
 TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
@@ -28,27 +27,28 @@ if not TOKEN:
 BOT_USERNAME = os.getenv("TELEGRAM_BOT_USERNAME", "Voice2mp3_RoBot")
 ADMIN_ID = int(os.getenv("TELEGRAM_ADMIN_ID", "0"))
 if ADMIN_ID == 0:
-    print("Warning: TELEGRAM_ADMIN_ID not set or 0.", file=sys.stderr)
+    print("Warning: TELEGRAM_ADMIN_ID not set or 0. Admin features will be disabled.", file=sys.stderr)
 
 DOWNLOAD_DIR = "/tmp/downloads"
 OUTPUT_DIR = "/tmp/outputs"
 CHANNELS_FILE = "channels.json"
+
 os.makedirs(DOWNLOAD_DIR, exist_ok=True)
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 # Telegram 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)
+LANGUAGE_SELECTION, MAIN_MENU, CONVERT_AUDIO_CHOICE, CONVERT_VOICE_TO_MP3, CONVERT_MP3_TO_VOICE, \
+    CUT_AUDIO_FILE, CUT_AUDIO_RANGE, VIDEO_CONVERSION_MODE, CONVERT_VIDEO_TO_NOTE, CONVERT_NOTE_TO_VIDEO, \
+    WAITING_FOR_MEMBERSHIP, ADMIN_MENU, ADD_CHANNEL, LIST_REMOVE_CHANNELS = range(14)
 
 # Load and save channels
-
 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)
+            print(f"Error decoding JSON from {CHANNELS_FILE}. Returning empty list.", file=sys.stderr)
     return []
 
 def save_required_channels(channels):
@@ -57,7 +57,736 @@ def save_required_channels(channels):
 
 REQUIRED_CHANNELS = load_required_channels()
 
-# Telegram application init
+# --- Language & Messages ---
+MESSAGES = {
+    "en": {
+        "welcome": "Hello! Please choose your language:",
+        "language_chosen": "Language set to English.",
+        "main_menu": "Welcome to the Audio/Video Converter Bot!\nWhat would you like to do?",
+        "audio_menu_text": "Choose an audio conversion option:",
+        "cut_audio_intro": "Please send me an audio file (MP3 or Voice message) you want to cut.",
+        "cut_audio_range_prompt": "Now, send me the time range in 'MM.SS-MM.SS' format (e.g., 00.21-00.54).\n\nMax duration for cutting is 5 minutes for MP3s and 2 minutes for Voice messages. If your file is longer, only the first part will be processed.",
+        "invalid_time_format": "Invalid time format. Please use 'MM.SS-MM.SS' (e.g., 00.21-00.54).",
+        "processing": "Processing your request, please wait...",
+        "audio_converted": "Here is your converted audio:",
+        "audio_cut_success": "Here is your trimmed audio:",
+        "no_audio_file": "Please send an audio file (MP3 or Voice message) to proceed.",
+        "video_menu_text": "Choose a video conversion option:",
+        "not_a_video": "Please send a video file to convert.",
+        "video_note_converted": "Here is your converted video note:",
+        "video_converted": "Here is your converted video:",
+        "membership_required": "To use this bot without limitations, please join the following channels:",
+        "membership_check_button": "I have joined!",
+        "admin_menu": "Welcome to the Admin Panel! What do you want to do?",
+        "add_channel_prompt": "Please send me the **username** or **ID** of the channel you want to add (e.g., `@mychannel` or `-1001234567890`).\n\n**Important:** The bot must be an admin in this channel with 'Invite Users' and 'Get Chat Member' permissions to verify membership.",
+        "channel_already_added": "This channel is already in the list.",
+        "channel_added_success": "Channel '{channel_name}' added successfully! ID: `{channel_id}`\n\n**Bot's Admin Status:** {status}",
+        "channel_not_found": "Could not find the channel. Please ensure the username/ID is correct and the bot is a member of the channel.",
+        "channel_permission_error": "Bot is not an admin or lacks necessary permissions (Invite Users, Get Chat Member) in this channel.",
+        "list_channels": "Current required channels:\n{channels_list}",
+        "no_channels_added": "No required channels added yet.",
+        "select_channel_to_remove": "Select a channel to remove:",
+        "channel_removed_success": "Channel '{channel_name}' removed successfully.",
+        "cancel_operation": "Operation cancelled. Returning to main menu.",
+        "unknown_command": "Unknown command. Please use the menu buttons or /start.",
+        "error_occurred": "An error occurred while processing your request. Please try again later.",
+        "not_admin": "You are not authorized to access the admin panel.",
+        "admin_permission_check": "Checking bot's admin status in channel {channel_name}...",
+        "bot_is_admin": "✅ Bot is an admin with required permissions.",
+        "bot_not_admin": "❌ Bot is not an admin or lacks 'Invite Users' and 'Get Chat Member' permissions.",
+        "bot_cannot_check_admin": "⚠️ Could not verify bot's admin status in this channel. Please ensure the bot is an admin with 'Invite Users' and 'Get Chat Member' permissions."
+    },
+    "fa": {
+        "welcome": "سلام! لطفاً زبان خود را انتخاب کنید:",
+        "language_chosen": "زبان به فارسی تنظیم شد.",
+        "main_menu": "به ربات تبدیل صدا/ویدیو خوش آمدید!\nچه کاری می‌خواهید انجام دهید؟",
+        "audio_menu_text": "یک گزینه برای تبدیل صدا انتخاب کنید:",
+        "cut_audio_intro": "لطفاً یک فایل صوتی (MP3 یا ویس) که می‌خواهید برش دهید را برای من بفرستید.",
+        "cut_audio_range_prompt": "اکنون، محدوده زمانی مورد نظر را با فرمت 'دقیقه.ثانیه-دقیقه.ثانیه' (مثال: 00.21-00.54) ارسال کنید.\n\nحداکثر زمان برش برای فایل‌های MP3 پنج دقیقه و برای ویس‌های تلگرام دو دقیقه است. اگر فایل شما طولانی‌تر باشد، فقط بخش ابتدایی آن پردازش می‌شود.",
+        "invalid_time_format": "فرمت زمان نامعتبر است. لطفاً از فرمت 'MM.SS-MM.SS' (مثال: 00.21-00.54) استفاده کنید.",
+        "processing": "در حال پردازش درخواست شما، لطفاً منتظر بمانید...",
+        "audio_converted": "فایل صوتی تبدیل شده شما:",
+        "audio_cut_success": "فایل صوتی برش خورده شما:",
+        "no_audio_file": "لطفاً یک فایل صوتی (MP3 یا ویس) برای ادامه ارسال کنید.",
+        "video_menu_text": "یک گزینه برای تبدیل ویدیو انتخاب کنید:",
+        "not_a_video": "لطفاً یک فایل ویدیویی برای تبدیل ارسال کنید.",
+        "video_note_converted": "ویدیوی دایره‌ای تبدیل شده شما:",
+        "video_converted": "ویدیوی تبدیل شده شما:",
+        "membership_required": "برای استفاده نامحدود از ربات، لطفاً در کانال‌های زیر عضو شوید:",
+        "membership_check_button": "عضو شدم!",
+        "admin_menu": "به پنل مدیریت خوش آمدید! چه کاری می‌خواهید انجام دهید؟",
+        "add_channel_prompt": "لطفاً **یوزرنیم** یا **آیدی** کانالی که می‌خواهید اضافه کنید را ارسال کنید (مثال: `@mychannel` یا `-1001234567890`).\n\n**مهم:** ربات باید در این کانال ادمین باشد و دسترسی‌های 'دعوت کاربر' و 'دریافت اطلاعات اعضا' را داشته باشد تا بتواند عضویت را بررسی کند.",
+        "channel_already_added": "این کانال از قبل اضافه شده است.",
+        "channel_added_success": "کانال '{channel_name}' با موفقیت اضافه شد! آیدی: `{channel_id}`\n\n**وضعیت ادمین ربات:** {status}",
+        "channel_not_found": "کانال پیدا نشد. لطفاً مطمئن شوید یوزرنیم/آیدی صحیح است و ربات عضو کانال است.",
+        "channel_permission_error": "ربات ادمین نیست یا دسترسی‌های لازم (دعوت کاربر، دریافت اطلاعات اعضا) را در این کانال ندارد.",
+        "list_channels": "کانال‌های اجباری فعلی:\n{channels_list}",
+        "no_channels_added": "هنوز کانالی برای عضویت اجباری اضافه نشده است.",
+        "select_channel_to_remove": "یک کانال برای حذف انتخاب کنید:",
+        "channel_removed_success": "کانال '{channel_name}' با موفقیت حذف شد.",
+        "cancel_operation": "عملیات لغو شد. بازگشت به منوی اصلی.",
+        "unknown_command": "دستور نامشخص. لطفاً از دکمه‌های منو یا /start استفاده کنید.",
+        "error_occurred": "خطایی در پردازش درخواست شما رخ داد. لطفاً بعداً امتحان کنید.",
+        "not_admin": "شما اجازه دسترسی به پنل ادمین را ندارید.",
+        "admin_permission_check": "در حال بررسی وضعیت ادمین ربا�� در کانال {channel_name}...",
+        "bot_is_admin": "✅ ربات ادمین است و دسترسی‌های لازم را دارد.",
+        "bot_not_admin": "❌ ربات ادمین نیست یا دسترسی‌های 'دعوت کاربر' و 'دریافت اطلاعات اعضا' را ندارد.",
+        "bot_cannot_check_admin": "⚠️ امکان بررسی وضعیت ادمین ربات در این کانال وجود ندارد. لطفاً اطمینان حاصل کنید که ربات ادمین است و دسترسی‌های 'دعوت کاربر' و 'دریافت اطلاعات اعضا' را دارد."
+    }
+}
+
+# --- Utility Functions ---
+async def get_user_language(user_id, context):
+    user_data = context.user_data
+    if 'language' not in user_data:
+        # Default to Persian if not set
+        user_data['language'] = 'fa'
+    return user_data['language']
+
+def get_message(user_lang, key, **kwargs):
+    return MESSAGES.get(user_lang, MESSAGES["en"]).get(key, MESSAGES["en"][key]).format(**kwargs)
+
+async def check_membership(update, context):
+    user_id = update.effective_user.id
+    user_lang = await get_user_language(user_id, context)
+
+    if not REQUIRED_CHANNELS:
+        return True # No channels required, proceed
+
+    is_member = True
+    not_joined_channels = []
+
+    for channel_info in REQUIRED_CHANNELS:
+        channel_id = channel_info['id']
+        try:
+            member = await context.bot.get_chat_member(chat_id=channel_id, user_id=user_id)
+            if member.status not in [ChatMemberStatus.MEMBER, ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.OWNER]:
+                is_member = False
+                not_joined_channels.append(channel_info)
+        except Exception as e:
+            print(f"Error checking membership for channel {channel_id}: {e}", file=sys.stderr)
+            # If there's an error (e.g., bot not in channel, channel not found), assume not joined
+            is_member = False
+            not_joined_channels.append(channel_info)
+
+    if not is_member:
+        keyboard_buttons = []
+        message_text = get_message(user_lang, "membership_required") + "\n"
+        for i, channel in enumerate(not_joined_channels):
+            channel_name = channel.get('name', channel['id'])
+            message_text += f"- {channel_name}: {channel['link']}\n"
+        
+        keyboard_buttons.append([InlineKeyboardButton(get_message(user_lang, "membership_check_button"), callback_data="check_membership_again")])
+        
+        reply_markup = InlineKeyboardMarkup(keyboard_buttons)
+        await update.message.reply_text(message_text, reply_markup=reply_markup, parse_mode=ParseMode.HTML)
+        return False
+    return True
+
+async def send_main_menu(update, context):
+    user_lang = await get_user_language(update.effective_user.id, context)
+    keyboard = [
+        [InlineKeyboardButton(get_message(user_lang, "audio_menu"), callback_data="audio_menu")],
+        [InlineKeyboardButton(get_message(user_lang, "video_menu"), callback_data="video_menu")]
+    ]
+    reply_markup = InlineKeyboardMarkup(keyboard)
+    await update.message.reply_text(get_message(user_lang, "main_menu"), reply_markup=reply_markup)
+    return MAIN_MENU
+
+# --- Audio Processing ---
+async def convert_ogg_to_mp3(ogg_file_path):
+    output_path = os.path.join(OUTPUT_DIR, os.path.basename(ogg_file_path).replace(".ogg", ".mp3"))
+    audio = AudioSegment.from_ogg(ogg_file_path)
+    audio.export(output_path, format="mp3")
+    return output_path
+
+async def convert_mp3_to_ogg_opus(mp3_file_path):
+    output_path = os.path.join(OUTPUT_DIR, os.path.basename(mp3_file_path).replace(".mp3", ".ogg"))
+    audio = AudioSegment.from_mp3(mp3_file_path)
+    # Telegram voice notes are OGG Opus. Use a reasonable bitrate.
+    # pydub's default ogg export uses libvorbis. For opus, ffmpeg might be needed directly.
+    # Let's use ffmpeg via subprocess for explicit Opus encoding.
+    command = [
+        "ffmpeg", "-i", mp3_file_path,
+        "-c:a", "libopus", "-b:a", "32k", # Typical Opus bitrate for voice notes
+        "-vbr", "on", "-compression_level", "10", # VBR on, max compression
+        "-map_metadata", "-1", # Remove metadata
+        output_path
+    ]
+    try:
+        subprocess.run(command, check=True, capture_output=True)
+        return output_path
+    except subprocess.CalledProcessError as e:
+        print(f"Error converting MP3 to OGG Opus with ffmpeg: {e.stderr.decode()}", file=sys.stderr)
+        raise
+
+async def cut_audio_segment(input_file_path, start_ms, end_ms):
+    output_path = os.path.join(OUTPUT_DIR, f"cut_{os.path.basename(input_file_path)}")
+    audio = AudioSegment.from_file(input_file_path)
+    cut_audio = audio[start_ms:end_ms]
+    cut_audio.export(output_path, format="mp3") # Always export cut audio as MP3
+    return output_path
+
+# --- Video Processing ---
+async def convert_video_to_note(input_file_path):
+    output_path = os.path.join(OUTPUT_DIR, f"note_{os.path.basename(input_file_path).replace('.', '_note.')}")
+    # Convert to circle video (video note). Requires specific resolution (e.g., 640x640), no audio, and short duration.
+    # Telegram usually expects square video for notes, no audio track, and specific bitrate/codec.
+    # Assuming input might be non-square, we can crop/scale.
+    # For simplicity, let's just convert format and ensure it's square and short (e.g., < 1 min)
+    # We will use ffmpeg directly for better control.
+    
+    # Try to get input video duration
+    try:
+        probe_command = ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", input_file_path]
+        duration_str = subprocess.check_output(probe_command, universal_newlines=True).strip()
+        duration_seconds = float(duration_str)
+        if duration_seconds > 60: # Limit to 60 seconds for video notes
+            print("Video too long for note, trimming to 60 seconds.")
+            trim_duration = 60
+        else:
+            trim_duration = duration_seconds
+    except Exception as e:
+        print(f"Could not get video duration, assuming 60s max: {e}", file=sys.stderr)
+        trim_duration = 60 # Default to 60s max if duration cannot be determined
+
+    command = [
+        "ffmpeg", "-i", input_file_path,
+        "-vf", "scale='min(iw,ih):min(iw,ih)',crop='min(iw,ih):min(iw,ih)'", # Crop to square
+        "-t", str(trim_duration), # Trim to max duration
+        "-c:v", "libx264", "-b:v", "800k", # H.264, target bitrate
+        "-preset", "ultrafast", # Faster encoding
+        "-an", # No audio for video notes
+        "-f", "mp4", # Ensure MP4 format
+        output_path
+    ]
+    try:
+        subprocess.run(command, check=True, capture_output=True)
+        return output_path
+    except subprocess.CalledProcessError as e:
+        print(f"Error converting video to note with ffmpeg: {e.stderr.decode()}", file=sys.stderr)
+        raise
+
+async def convert_note_to_video(input_file_path):
+    # A video note is essentially a video with specific Telegram metadata.
+    # To convert to "normal" video, often just changing container/codec or removing some metadata is enough.
+    # For simplicity, we'll convert it to a standard MP4 with a common codec.
+    output_path = os.path.join(OUTPUT_DIR, f"video_{os.path.basename(input_file_path).replace('.', '_video.')}.mp4")
+    command = [
+        "ffmpeg", "-i", input_file_path,
+        "-c:v", "libx264", "-c:a", "aac", # Common video/audio codecs
+        "-b:a", "128k", "-b:v", "1500k", # Common bitrates
+        "-movflags", "faststart", # For web streaming optimization
+        "-f", "mp4", # Ensure MP4 format
+        output_path
+    ]
+    try:
+        subprocess.run(command, check=True, capture_output=True)
+        return output_path
+    except subprocess.CalledProcessError as e:
+        print(f"Error converting note to video with ffmpeg: {e.stderr.decode()}", file=sys.stderr)
+        raise
+
+# --- Telegram Bot Handlers ---
+
+# Entry point for the bot: Language selection
+async def start(update: Update, context):
+    user_lang = await get_user_language(update.effective_user.id, context) # Get current lang, default if not set
+    if 'language_chosen' not in context.user_data: # Only show language selection on first start
+        keyboard = [
+            [InlineKeyboardButton("English 🇬🇧", callback_data="set_lang_en")],
+            [InlineKeyboardButton("فارسی 🇮🇷", callback_data="set_lang_fa")]
+        ]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        await update.message.reply_text(get_message(user_lang, "welcome"), reply_markup=reply_markup)
+        return LANGUAGE_SELECTION
+    else:
+        # If language is already set, check membership and go to main menu
+        if await check_membership(update, context):
+            return await send_main_menu(update, context)
+        return WAITING_FOR_MEMBERSHIP
+
+async def set_language(update: Update, context):
+    query = update.callback_query
+    await query.answer()
+    lang = query.data.split('_')[2]
+    context.user_data['language'] = lang
+    context.user_data['language_chosen'] = True # Mark language as chosen
+
+    user_lang = await get_user_language(query.from_user.id, context)
+    await query.edit_message_text(get_message(user_lang, "language_chosen"))
+
+    # After setting language, check membership
+    if await check_membership(query, context): # Pass query for message update
+        return await send_main_menu(query, context)
+    return WAITING_FOR_MEMBERSHIP
+
+async def check_membership_callback(update: Update, context):
+    query = update.callback_query
+    await query.answer()
+    
+    if await check_membership(query, context):
+        await query.edit_message_text(get_message(await get_user_language(query.from_user.id, context), "main_menu"),
+                                     reply_markup=InlineKeyboardMarkup([
+                                         [InlineKeyboardButton(get_message(await get_user_language(query.from_user.id, context), "audio_menu"), callback_data="audio_menu")],
+                                         [InlineKeyboardButton(get_message(await get_user_language(query.from_user.id, context), "video_menu"), callback_data="video_menu")]
+                                     ]))
+        return MAIN_MENU
+    return WAITING_FOR_MEMBERSHIP # Still waiting if not joined
+
+async def main_menu_callback(update: Update, context):
+    query = update.callback_query
+    await query.answer()
+    user_lang = await get_user_language(query.from_user.id, context)
+
+    if not await check_membership(query, context):
+        return WAITING_FOR_MEMBERSHIP
+
+    if query.data == "audio_menu":
+        keyboard = [
+            [InlineKeyboardButton(get_message(user_lang, "convert_voice_to_mp3"), callback_data="convert_voice_to_mp3")],
+            [InlineKeyboardButton(get_message(user_lang, "convert_mp3_to_voice"), callback_data="convert_mp3_to_voice")],
+            [InlineKeyboardButton(get_message(user_lang, "cut_audio"), callback_data="cut_audio")],
+            [InlineKeyboardButton(get_message(user_lang, "back_to_main_menu"), callback_data="main_menu")]
+        ]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        await query.edit_message_text(get_message(user_lang, "audio_menu_text"), reply_markup=reply_markup)
+        return CONVERT_AUDIO_CHOICE
+    
+    elif query.data == "video_menu":
+        keyboard = [
+            [InlineKeyboardButton(get_message(user_lang, "convert_video_to_note"), callback_data="convert_video_to_note")],
+            [InlineKeyboardButton(get_message(user_lang, "convert_note_to_video"), callback_data="convert_note_to_video")],
+            [InlineKeyboardButton(get_message(user_lang, "back_to_main_menu"), callback_data="main_menu")]
+        ]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        await query.edit_message_text(get_message(user_lang, "video_menu_text"), reply_markup=reply_markup)
+        return VIDEO_CONVERSION_MODE
+
+    elif query.data == "main_menu":
+        await send_main_menu(query, context)
+        return MAIN_MENU
+    
+    return MAIN_MENU
+
+# --- Audio Conversion Handlers ---
+async def start_convert_voice_to_mp3(update: Update, context):
+    query = update.callback_query
+    await query.answer()
+    user_lang = await get_user_language(query.from_user.id, context)
+
+    if not await check_membership(query, context):
+        return WAITING_FOR_MEMBERSHIP
+
+    await query.edit_message_text(get_message(user_lang, "send_voice_for_mp3"))
+    return CONVERT_VOICE_TO_MP3
+
+async def handle_voice_to_mp3(update: Update, context):
+    user_lang = await get_user_language(update.effective_user.id, context)
+    if update.message.voice:
+        file_id = update.message.voice.file_id
+        file = await context.bot.get_file(file_id)
+        input_file_path = os.path.join(DOWNLOAD_DIR, f"{file_id}.ogg")
+        await file.download_to_drive(input_file_path)
+
+        await update.message.reply_text(get_message(user_lang, "processing"))
+        try:
+            output_mp3_path = await convert_ogg_to_mp3(input_file_path)
+            await update.message.reply_audio(audio=open(output_mp3_path, 'rb'), caption=get_message(user_lang, "audio_converted"))
+        except Exception as e:
+            print(f"Error converting voice to mp3: {e}", file=sys.stderr)
+            await update.message.reply_text(get_message(user_lang, "error_occurred"))
+        finally:
+            os.remove(input_file_path)
+            if 'output_mp3_path' in locals() and os.path.exists(output_mp3_path):
+                os.remove(output_mp3_path)
+        
+        return await send_main_menu(update, context) # Go back to main menu
+    else:
+        await update.message.reply_text(get_message(user_lang, "no_voice_file"))
+        return CONVERT_VOICE_TO_MP3
+
+async def start_convert_mp3_to_voice(update: Update, context):
+    query = update.callback_query
+    await query.answer()
+    user_lang = await get_user_language(query.from_user.id, context)
+
+    if not await check_membership(query, context):
+        return WAITING_FOR_MEMBERSHIP
+
+    await query.edit_message_text(get_message(user_lang, "send_mp3_for_voice"))
+    return CONVERT_MP3_TO_VOICE
+
+async def handle_mp3_to_voice(update: Update, context):
+    user_lang = await get_user_language(update.effective_user.id, context)
+    if update.message.audio and update.message.audio.mime_type == 'audio/mpeg':
+        file_id = update.message.audio.file_id
+        file = await context.bot.get_file(file_id)
+        input_file_path = os.path.join(DOWNLOAD_DIR, f"{file_id}.mp3")
+        await file.download_to_drive(input_file_path)
+
+        await update.message.reply_text(get_message(user_lang, "processing"))
+        try:
+            output_ogg_path = await convert_mp3_to_ogg_opus(input_file_path)
+            # Send as voice message
+            await update.message.reply_voice(voice=open(output_ogg_path, 'rb'), caption=get_message(user_lang, "audio_converted"))
+        except Exception as e:
+            print(f"Error converting mp3 to voice: {e}", file=sys.stderr)
+            await update.message.reply_text(get_message(user_lang, "error_occurred"))
+        finally:
+            os.remove(input_file_path)
+            if 'output_ogg_path' in locals() and os.path.exists(output_ogg_path):
+                os.remove(output_ogg_path)
+        
+        return await send_main_menu(update, context) # Go back to main menu
+    else:
+        await update.message.reply_text(get_message(user_lang, "no_mp3_file"))
+        return CONVERT_MP3_TO_VOICE
+
+# --- Audio Cutting Handlers ---
+async def start_cut_audio(update: Update, context):
+    query = update.callback_query
+    await query.answer()
+    user_lang = await get_user_language(query.from_user.id, context)
+
+    if not await check_membership(query, context):
+        return WAITING_FOR_MEMBERSHIP
+
+    await query.edit_message_text(get_message(user_lang, "cut_audio_intro"))
+    return CUT_AUDIO_FILE
+
+async def handle_cut_audio_file(update: Update, context):
+    user_lang = await get_user_language(update.effective_user.id, context)
+    file_id = None
+    file_extension = None
+
+    if update.message.audio and update.message.audio.mime_type == 'audio/mpeg':
+        file_id = update.message.audio.file_id
+        file_extension = "mp3"
+        context.user_data['audio_type'] = 'mp3'
+    elif update.message.voice:
+        file_id = update.message.voice.file_id
+        file_extension = "ogg"
+        context.user_data['audio_type'] = 'voice'
+    else:
+        await update.message.reply_text(get_message(user_lang, "no_audio_file"))
+        return CUT_AUDIO_FILE # Stay in this state, waiting for audio file
+
+    file = await context.bot.get_file(file_id)
+    input_file_path = os.path.join(DOWNLOAD_DIR, f"{file_id}.{file_extension}")
+    await file.download_to_drive(input_file_path)
+    context.user_data['input_file_path'] = input_file_path
+
+    await update.message.reply_text(get_message(user_lang, "cut_audio_range_prompt"))
+    return CUT_AUDIO_RANGE
+
+async def handle_cut_audio_range(update: Update, context):
+    user_lang = await get_user_language(update.effective_user.id, context)
+    time_range_str = update.message.text
+
+    match = re.match(r"^(\d{2})\.(\d{2})-(\d{2})\.(\d{2})$", time_range_str)
+    if not match:
+        await update.message.reply_text(get_message(user_lang, "invalid_time_format"))
+        return CUT_AUDIO_RANGE # Stay in this state, waiting for correct format
+
+    start_min, start_sec, end_min, end_sec = map(int, match.groups())
+
+    start_ms = (start_min * 60 + start_sec) * 1000
+    end_ms = (end_min * 60 + end_sec) * 1000
+
+    input_file_path = context.user_data.get('input_file_path')
+    if not input_file_path or not os.path.exists(input_file_path):
+        await update.message.reply_text(get_message(user_lang, "error_occurred"))
+        return await send_main_menu(update, context)
+
+    try:
+        audio_info = AudioSegment.from_file(input_file_path)
+        audio_duration_ms = len(audio_info)
+
+        # Apply max duration limits
+        max_duration_ms = 5 * 60 * 1000 if context.user_data.get('audio_type') == 'mp3' else 2 * 60 * 1000
+        if audio_duration_ms > max_duration_ms:
+            # If file is longer than max allowed, cut only from the start to max_duration
+            audio_duration_ms = max_duration_ms
+            
+        if end_ms > audio_duration_ms:
+            end_ms = audio_duration_ms # Cap end time to actual (or limited) duration
+        
+        if start_ms >= end_ms:
+            await update.message.reply_text(get_message(user_lang, "invalid_time_range")) # e.g. start > end
+            return CUT_AUDIO_RANGE
+
+        await update.message.reply_text(get_message(user_lang, "processing"))
+        
+        output_cut_path = await cut_audio_segment(input_file_path, start_ms, end_ms)
+        await update.message.reply_audio(audio=open(output_cut_path, 'rb'), caption=get_message(user_lang, "audio_cut_success"))
+    
+    except Exception as e:
+        print(f"Error cutting audio: {e}", file=sys.stderr)
+        await update.message.reply_text(get_message(user_lang, "error_occurred"))
+    finally:
+        if input_file_path and os.path.exists(input_file_path):
+            os.remove(input_file_path)
+        if 'output_cut_path' in locals() and os.path.exists(output_cut_path):
+            os.remove(output_cut_path)
+        if 'input_file_path' in context.user_data:
+            del context.user_data['input_file_path']
+        if 'audio_type' in context.user_data:
+            del context.user_data['audio_type']
+    
+    return await send_main_menu(update, context)
+
+# --- Video Conversion Handlers ---
+async def start_convert_video_to_note(update: Update, context):
+    query = update.callback_query
+    await query.answer()
+    user_lang = await get_user_language(query.from_user.id, context)
+
+    if not await check_membership(query, context):
+        return WAITING_FOR_MEMBERSHIP
+
+    await query.edit_message_text(get_message(user_lang, "send_video_for_note"))
+    return CONVERT_VIDEO_TO_NOTE
+
+async def handle_video_to_note(update: Update, context):
+    user_lang = await get_user_language(update.effective_user.id, context)
+    if update.message.video:
+        file_id = update.message.video.file_id
+        file = await context.bot.get_file(file_id)
+        input_file_path = os.path.join(DOWNLOAD_DIR, f"{file_id}.mp4") # Assume mp4, or get actual extension
+        await file.download_to_drive(input_file_path)
+
+        await update.message.reply_text(get_message(user_lang, "processing"))
+        try:
+            output_note_path = await convert_video_to_note(input_file_path)
+            # Send as video note
+            await update.message.reply_video_note(video_note=open(output_note_path, 'rb'))
+            await update.message.reply_text(get_message(user_lang, "video_note_converted"))
+        except Exception as e:
+            print(f"Error converting video to note: {e}", file=sys.stderr)
+            await update.message.reply_text(get_message(user_lang, "error_occurred"))
+        finally:
+            os.remove(input_file_path)
+            if 'output_note_path' in locals() and os.path.exists(output_note_path):
+                os.remove(output_note_path)
+        
+        return await send_main_menu(update, context)
+    else:
+        await update.message.reply_text(get_message(user_lang, "not_a_video"))
+        return CONVERT_VIDEO_TO_NOTE
+
+async def start_convert_note_to_video(update: Update, context):
+    query = update.callback_query
+    await query.answer()
+    user_lang = await get_user_language(query.from_user.id, context)
+
+    if not await check_membership(query, context):
+        return WAITING_FOR_MEMBERSHIP
+
+    await query.edit_message_text(get_message(user_lang, "send_note_for_video"))
+    return CONVERT_NOTE_TO_VIDEO
+
+async def handle_note_to_video(update: Update, context):
+    user_lang = await get_user_language(update.effective_user.id, context)
+    if update.message.video_note:
+        file_id = update.message.video_note.file_id
+        file = await context.bot.get_file(file_id)
+        input_file_path = os.path.join(DOWNLOAD_DIR, f"{file_id}.mp4") # Video notes are mp4
+        await file.download_to_drive(input_file_path)
+
+        await update.message.reply_text(get_message(user_lang, "processing"))
+        try:
+            output_video_path = await convert_note_to_video(input_file_path)
+            await update.message.reply_video(video=open(output_video_path, 'rb'), caption=get_message(user_lang, "video_converted"))
+        except Exception as e:
+            print(f"Error converting note to video: {e}", file=sys.stderr)
+            await update.message.reply_text(get_message(user_lang, "error_occurred"))
+        finally:
+            os.remove(input_file_path)
+            if 'output_video_path' in locals() and os.path.exists(output_video_path):
+                os.remove(output_video_path)
+        
+        return await send_main_menu(update, context)
+    else:
+        await update.message.reply_text(get_message(user_lang, "not_a_video_note"))
+        return CONVERT_NOTE_TO_VIDEO
+
+# --- Admin Panel Handlers ---
+async def admin_link(update: Update, context):
+    user_lang = await get_user_language(update.effective_user.id, context)
+    if update.effective_user.id != ADMIN_ID:
+        await update.message.reply_text(get_message(user_lang, "not_admin"))
+        return ConversationHandler.END # End conversation if not admin
+
+    keyboard = [
+        [InlineKeyboardButton(get_message(user_lang, "add_channel"), callback_data="admin_add_channel")],
+        [InlineKeyboardButton(get_message(user_lang, "list_remove_channels"), callback_data="admin_list_remove_channels")],
+        [InlineKeyboardButton(get_message(user_lang, "back_to_main_menu"), callback_data="main_menu")]
+    ]
+    reply_markup = InlineKeyboardMarkup(keyboard)
+    await update.message.reply_text(get_message(user_lang, "admin_menu"), reply_markup=reply_markup)
+    return ADMIN_MENU
+
+async def admin_menu_callback(update: Update, context):
+    query = update.callback_query
+    await query.answer()
+    user_lang = await get_user_language(query.from_user.id, context)
+
+    if query.from_user.id != ADMIN_ID:
+        await query.edit_message_text(get_message(user_lang, "not_admin"))
+        return ConversationHandler.END
+    
+    if query.data == "admin_add_channel":
+        await query.edit_message_text(get_message(user_lang, "add_channel_prompt"), parse_mode=ParseMode.MARKDOWN)
+        return ADD_CHANNEL
+    elif query.data == "admin_list_remove_channels":
+        await list_remove_channels(update, context) # Re-use the list function
+        return LIST_REMOVE_CHANNELS
+    elif query.data == "main_menu":
+        return await send_main_menu(query, context)
+    
+    return ADMIN_MENU
+
+async def add_channel_handler(update: Update, context):
+    user_lang = await get_user_language(update.effective_user.id, context)
+    channel_identifier = update.message.text.strip()
+    
+    channel_id = None
+    channel_name = None
+    
+    await update.message.reply_text(get_message(user_lang, "admin_permission_check").format(channel_name=channel_identifier))
+
+    try:
+        # Try to get chat object using identifier
+        chat = await context.bot.get_chat(channel_identifier)
+        channel_id = chat.id
+        channel_name = chat.title if chat.title else chat.username if chat.username else str(chat.id)
+        
+        # Check if already added
+        for c in REQUIRED_CHANNELS:
+            if c['id'] == channel_id:
+                await update.message.reply_text(get_message(user_lang, "channel_already_added"))
+                return ADMIN_MENU # Go back to admin menu
+        
+        # Check bot's admin status in the channel
+        bot_member = await context.bot.get_chat_member(chat_id=channel_id, user_id=context.bot.id)
+        is_bot_admin = bot_member.status in [ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.OWNER]
+        
+        can_invite_users = False
+        can_get_chat_members = False
+
+        if is_bot_admin:
+            if bot_member.can_invite_users and bot_member.can_post_messages and bot_member.can_manage_chat and bot_member.can_delete_messages: # Check required permissions
+                 can_invite_users = True # Can manage chat and post means can invite
+            if bot_member.can_manage_chat: # can_manage_chat often implies get_chat_member
+                can_get_chat_members = True
+        
+        bot_status_message = ""
+        if is_bot_admin and can_invite_users and can_get_chat_members:
+            bot_status_message = get_message(user_lang, "bot_is_admin")
+        elif is_bot_admin:
+            bot_status_message = get_message(user_lang, "bot_not_admin") # Admin but missing specific perms
+        else:
+            bot_status_message = get_message(user_lang, "bot_not_admin") # Not admin at all
+
+        REQUIRED_CHANNELS.append({
+            "id": channel_id,
+            "name": channel_name,
+            "link": chat.invite_link if chat.invite_link else f"https://t.me/{chat.username}" if chat.username else f"https://t.me/c/{str(channel_id).replace('-100', '')}",
+            "bot_is_admin": is_bot_admin,
+            "bot_can_invite_users": can_invite_users,
+            "bot_can_get_chat_members": can_get_chat_members
+        })
+        save_required_channels(REQUIRED_CHANNELS)
+        
+        await update.message.reply_text(get_message(user_lang, "channel_added_success").format(channel_name=channel_name, channel_id=channel_id, status=bot_status_message), parse_mode=ParseMode.MARKDOWN)
+
+    except Exception as e:
+        print(f"Error adding channel {channel_identifier}: {e}", file=sys.stderr)
+        if "chat not found" in str(e).lower() or "bad request: chat_id is empty" in str(e).lower():
+            await update.message.reply_text(get_message(user_lang, "channel_not_found"))
+        elif "bot is not a member of the channel" in str(e).lower():
+             await update.message.reply_text(get_message(user_lang, "channel_not_found"))
+        else:
+            await update.message.reply_text(get_message(user_lang, "error_occurred"))
+
+    # Return to admin menu after adding
+    keyboard = [
+        [InlineKeyboardButton(get_message(user_lang, "add_channel"), callback_data="admin_add_channel")],
+        [InlineKeyboardButton(get_message(user_lang, "list_remove_channels"), callback_data="admin_list_remove_channels")],
+        [InlineKeyboardButton(get_message(user_lang, "back_to_main_menu"), callback_data="main_menu")]
+    ]
+    reply_markup = InlineKeyboardMarkup(keyboard)
+    await update.message.reply_text(get_message(user_lang, "admin_menu"), reply_markup=reply_markup)
+    return ADMIN_MENU
+
+async def list_remove_channels(update: Update, context):
+    user_lang = await get_user_language(update.effective_user.id, context)
+
+    if not REQUIRED_CHANNELS:
+        message_text = get_message(user_lang, "no_channels_added")
+        keyboard = [[InlineKeyboardButton(get_message(user_lang, "back_to_admin_menu"), callback_data="admin_menu")]]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        if update.callback_query:
+            await update.callback_query.edit_message_text(message_text, reply_markup=reply_markup)
+        else:
+            await update.message.reply_text(message_text, reply_markup=reply_markup)
+        return ADMIN_MENU
+
+    message_text = get_message(user_lang, "list_channels").format(channels_list="")
+    keyboard_buttons = []
+    
+    for i, channel in enumerate(REQUIRED_CHANNELS):
+        channel_name = channel.get('name', channel['id'])
+        message_text += f"{i+1}. {channel_name} (ID: `{channel['id']}`)\n"
+        keyboard_buttons.append([InlineKeyboardButton(f"❌ {channel_name}", callback_data=f"remove_channel_{i}")])
+
+    keyboard_buttons.append([InlineKeyboardButton(get_message(user_lang, "back_to_admin_menu"), callback_data="admin_menu")])
+    reply_markup = InlineKeyboardMarkup(keyboard_buttons)
+
+    if update.callback_query:
+        await update.callback_query.edit_message_text(message_text, reply_markup=reply_markup, parse_mode=ParseMode.MARKDOWN)
+    else:
+        await update.message.reply_text(message_text, reply_markup=reply_markup, parse_mode=ParseMode.MARKDOWN)
+    
+    return LIST_REMOVE_CHANNELS
+
+async def remove_channel_handler(update: Update, context):
+    query = update.callback_query
+    await query.answer()
+    user_lang = await get_user_language(query.from_user.id, context)
+
+    if query.from_user.id != ADMIN_ID:
+        await query.edit_message_text(get_message(user_lang, "not_admin"))
+        return ConversationHandler.END
+
+    index_to_remove = int(query.data.split('_')[2])
+
+    if 0 <= index_to_remove < len(REQUIRED_CHANNELS):
+        removed_channel = REQUIRED_CHANNELS.pop(index_to_remove)
+        save_required_channels(REQUIRED_CHANNELS)
+        await query.edit_message_text(get_message(user_lang, "channel_removed_success").format(channel_name=removed_channel.get('name', removed_channel['id'])))
+    else:
+        await query.edit_message_text(get_message(user_lang, "error_occurred"))
+
+    # After removal, re-list channels or go back to admin menu
+    await list_remove_channels(update, context) # Show updated list
+    return LIST_REMOVE_CHANNELS
+
+
+# --- General Handlers ---
+async def cancel(update: Update, context):
+    user_lang = await get_user_language(update.effective_user.id, context)
+    await update.message.reply_text(get_message(user_lang, "cancel_operation"))
+    return await send_main_menu(update, context)
+
+async def error_handler(update: Update, context):
+    print(f"Error: {context.error} in update {update}", file=sys.stderr)
+    if update.effective_message:
+        user_lang = await get_user_language(update.effective_user.id, context)
+        await update.effective_message.reply_text(get_message(user_lang, "error_occurred"))
+
+# Flask application init
 app = Flask(__name__)
 _application_instance = None
 
@@ -67,22 +796,97 @@ async def get_telegram_application():
         print("Initializing Telegram bot Application for this worker...")
         _app = Application.builder().token(TOKEN).build()
 
+        # Define ConversationHandler with all states
         conv_handler = ConversationHandler(
             entry_points=[CommandHandler("start", start)],
-            states={},
-            fallbacks=[CommandHandler("cancel", cancel), CommandHandler("start", start)],
-            allow_reentry=True
+            states={
+                LANGUAGE_SELECTION: [
+                    CallbackQueryHandler(set_language, pattern=r"^set_lang_")
+                ],
+                WAITING_FOR_MEMBERSHIP: [
+                    CallbackQueryHandler(check_membership_callback, pattern="^check_membership_again$"),
+                    MessageHandler(filters.ALL & ~filters.COMMAND, lambda u, c: u.message.reply_text(get_message(c.user_data.get('language', 'fa'), "membership_required_stay"))) # Keep waiting
+                ],
+                MAIN_MENU: [
+                    CallbackQueryHandler(main_menu_callback, pattern="^(audio_menu|video_menu|main_menu)$")
+                ],
+                CONVERT_AUDIO_CHOICE: [
+                    CallbackQueryHandler(start_convert_voice_to_mp3, pattern="^convert_voice_to_mp3$"),
+                    CallbackQueryHandler(start_convert_mp3_to_voice, pattern="^convert_mp3_to_voice$"),
+                    CallbackQueryHandler(start_cut_audio, pattern="^cut_audio$"),
+                    CallbackQueryHandler(main_menu_callback, pattern="^main_menu$") # Back to main menu
+                ],
+                CONVERT_VOICE_TO_MP3: [
+                    MessageHandler(filters.VOICE, handle_voice_to_mp3),
+                    CommandHandler("cancel", cancel),
+                    MessageHandler(filters.ALL & ~filters.COMMAND, lambda u, c: u.message.reply_text(get_message(c.user_data.get('language', 'fa'), "no_voice_file"))) # Repeat prompt
+                ],
+                CONVERT_MP3_TO_VOICE: [
+                    MessageHandler(filters.AUDIO & filters.Document.MimeType("audio/mpeg"), handle_mp3_to_voice),
+                    CommandHandler("cancel", cancel),
+                    MessageHandler(filters.ALL & ~filters.COMMAND, lambda u, c: u.message.reply_text(get_message(c.user_data.get('language', 'fa'), "no_mp3_file"))) # Repeat prompt
+                ],
+                CUT_AUDIO_FILE: [
+                    MessageHandler(filters.AUDIO | filters.VOICE, handle_cut_audio_file),
+                    CommandHandler("cancel", cancel),
+                    MessageHandler(filters.ALL & ~filters.COMMAND, lambda u, c: u.message.reply_text(get_message(c.user_data.get('language', 'fa'), "no_audio_file"))) # Repeat prompt
+                ],
+                CUT_AUDIO_RANGE: [
+                    MessageHandler(filters.TEXT & ~filters.COMMAND, handle_cut_audio_range),
+                    CommandHandler("cancel", cancel),
+                    MessageHandler(filters.ALL & ~filters.COMMAND, lambda u, c: u.message.reply_text(get_message(c.user_data.get('language', 'fa'), "invalid_time_format"))) # Repeat prompt
+                ],
+                VIDEO_CONVERSION_MODE: [
+                    CallbackQueryHandler(start_convert_video_to_note, pattern="^convert_video_to_note$"),
+                    CallbackQueryHandler(start_convert_note_to_video, pattern="^convert_note_to_video$"),
+                    CallbackQueryHandler(main_menu_callback, pattern="^main_menu$") # Back to main menu
+                ],
+                CONVERT_VIDEO_TO_NOTE: [
+                    MessageHandler(filters.VIDEO, handle_video_to_note),
+                    CommandHandler("cancel", cancel),
+                    MessageHandler(filters.ALL & ~filters.COMMAND, lambda u, c: u.message.reply_text(get_message(c.user_data.get('language', 'fa'), "not_a_video")))
+                ],
+                CONVERT_NOTE_TO_VIDEO: [
+                    MessageHandler(filters.VIDEO_NOTE, handle_note_to_video),
+                    CommandHandler("cancel", cancel),
+                    MessageHandler(filters.ALL & ~filters.COMMAND, lambda u, c: u.message.reply_text(get_message(c.user_data.get('language', 'fa'), "not_a_video_note")))
+                ],
+                ADMIN_MENU: [
+                    CallbackQueryHandler(admin_menu_callback, pattern="^admin_(add_channel|list_remove_channels)$"),
+                    CallbackQueryHandler(main_menu_callback, pattern="^main_menu$")
+                ],
+                ADD_CHANNEL: [
+                    MessageHandler(filters.TEXT & ~filters.COMMAND, add_channel_handler),
+                    CommandHandler("cancel", cancel),
+                    CommandHandler("link", admin_link) # Allow re-entry to admin menu
+                ],
+                LIST_REMOVE_CHANNELS: [
+                    CallbackQueryHandler(remove_channel_handler, pattern="^remove_channel_\d+$"),
+                    CallbackQueryHandler(admin_menu_callback, pattern="^admin_menu$") # Back to admin menu
+                ]
+            },
+            fallbacks=[
+                CommandHandler("cancel", cancel),
+                CommandHandler("start", start),
+                CommandHandler("link", admin_link) # Link for admin access
+            ],
+            allow_reentry=True # Allow re-entry into the same conversation
         )
-
         _app.add_handler(conv_handler)
         _app.add_error_handler(error_handler)
-        await _app.initialize()  # <-- Fix: proper initialization
-        _application_instance = _app
+        
+        # Admin command list
+        await _app.bot.set_my_commands([
+            BotCommand("start", "Start the bot"),
+            BotCommand("cancel", "Cancel current operation"),
+            BotCommand("link", "Admin panel (Admin only)")
+        ])
+
+        await _app.initialize()
         print("Telegram bot Application initialized.")
     return _application_instance
 
 # Flask routes
-
 @app.route("/")
 async def index():
     return jsonify({"status": "ok", "message": "Telegram bot is running."})
@@ -100,10 +904,8 @@ async def set_webhook_route():
     webhook_url = os.getenv("WEBHOOK_URL")
     if not webhook_url:
         return jsonify({"status": "error", "message": "WEBHOOK_URL not set."}), 500
-
     if not webhook_url.endswith("/webhook"):
         webhook_url = f"{webhook_url.rstrip('/')}/webhook"
-
     try:
         await application.bot.set_webhook(url=webhook_url)
         return jsonify({"status": "success", "message": f"Webhook set to {webhook_url}"})
@@ -115,15 +917,13 @@ async def set_webhook_route():
 if __name__ == "__main__":
     import asyncio
     print("Starting Flask app in local mode...")
-    asyncio.run(get_telegram_application())
-    app.run(host='0.0.0.0', port=int(os.environ.get("PORT", 7860)))
-
-# Placeholder handlers (implement as needed)
-async def start(update, context):
-    await update.message.reply_text("Bot started!")
-
-async def cancel(update, context):
-    await update.message.reply_text("Operation cancelled.")
-
-async def error_handler(update, context):
-    print(f"Error: {context.error}", file=sys.stderr)
+    # Initialize the application in a separate asyncio task if running locally
+    # Otherwise, it will be initialized by the webhook call in a production environment
+    try:
+        asyncio.run(get_telegram_application())
+    except RuntimeError as e:
+        if "cannot run loop while another loop is running" in str(e):
+            print("Loop already running, likely in an IDE. Skipping explicit asyncio.run.")
+        else:
+            raise
+    app.run(host='0.0.0.0', port=int(os.environ.get("PORT", 7860)))