# ==================== بخش اول: ایمپورت‌ها و تنظیمات پایه ====================
import os
import logging
import asyncio
import json
import random
import time
from datetime import datetime, timedelta
from dotenv import load_dotenv
import aiofiles
import httpx
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup, ChatMember
from telegram.ext import (
    Application, CommandHandler, CallbackQueryHandler,
    ContextTypes, MessageHandler, filters, ChatMemberHandler
)
from telegram.request import HTTPXRequest
import jdatetime
from babel.dates import format_datetime, format_date, format_time
from babel.numbers import format_number
import matplotlib.pyplot as plt
import io
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from num2words import num2words

load_dotenv()

TOKEN = os.getenv("BOT_TOKEN")
MASTER_ADMIN_ID = os.getenv("ADMIN_ID", "185308783")
DATA_FILE = "data.json"
data_lock = asyncio.Lock()

logging.basicConfig(
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
    level=logging.INFO
)
logger = logging.getLogger(__name__)

# ==================== تشخیص پروکسی ====================
def detect_proxy():
    logger.info("🔍 جستجوی پروکسی...")
    proxy_options = [
        {"url": "socks5://127.0.0.1:1080", "type": "socks5"},
        {"url": "http://127.0.0.1:8080", "type": "http"},
    ]
    for option in proxy_options:
        try:
            with httpx.Client(proxies=option["url"], timeout=1.0) as client:
                response = client.get(f"https://api.telegram.org/bot{TOKEN}/getMe")
                if response.status_code == 200:
                    logger.info(f"✅ پروکسی یافت شد: {option['url']}")
                    return option["url"]
        except:
            continue
    logger.info("⚠️ بدون پروکسی")
    return None

PROXY_URL = detect_proxy()

if not TOKEN:
    logger.error("❌ توکن یافت نشد!")
    exit(1)

# ==================== توابع دیتابیس ====================
def default_data():
    return {
        "users": {},
        "products": {},
        "inquiries": {},
        "auctions": {},
        "lawyers": {},
        "legal_consultations": {},
        "rentals": {},
        "ratings": {},
        "transactions": {},
        "subscriptions": {},
        "pending_payments": {},
        "marketplaces": {},
        "knowledge_base": {},
        "user_langs": {},
        "settings": {
            "income_model": "coin",
            "coin_price_toman": 30000,
            "coin_price_foreign": 0.85,
            "foreign_currency_symbol": "USDT",
            "min_coins_for_inquiry": 10,
            "min_coins_for_auction_bid": 20,
            "legal_consult_coin_cost": 20,
            "lawyer_monthly_fee": 50,
            "rental_monthly_fee_coins": 100,
            "rental_monthly_fee_toman": 50000,
            "rental_monthly_fee_usdt": 1.5,
            "rental_grace_period_days": 7,
            "min_coins_for_post": 5,
            "coin_cost_text": 1,
            "coin_cost_photo": 2,
            "coin_cost_video": 3,
            "coin_cost_document": 2,
            "coin_cost_link": 2,
            "ad_duration_hours": 72,
            "pinned_duration_hours": 24,
            "auction_duration_hours": 48,
            "admin_approval_required": False,
            "max_products_per_user": 20,
            "referral_bonus": 5,
            "referral_cooldown": 10,
            "referral_report_mode": "both",
            "archive_channel_id": "",
            "admin_username": "ModiriyateTjaratkhane",
            "coin_packages": [
                {"id": "pkg1", "coins": 10, "price_toman": 300000, "active": True},
                {"id": "pkg2", "coins": 25, "price_toman": 720000, "active": True},
                {"id": "pkg3", "coins": 50, "price_toman": 1400000, "active": True},
                {"id": "pkg4", "coins": 100, "price_toman": 2700000, "active": True},
                {"id": "pkg5", "coins": 200, "price_toman": 5200000, "active": True},
                {"id": "pkg6", "coins": 500, "price_toman": 12500000, "active": True},
            ],
            "subscription_plans": [
                {"id": "sub1", "name": "ماهانه", "days": 30, "price_toman": 60000, "active": True},
                {"id": "sub2", "name": "سه‌ماهه", "days": 90, "price_toman": 150000, "active": True},
                {"id": "sub3", "name": "شش‌ماهه", "days": 180, "price_toman": 270000, "active": True},
                {"id": "sub4", "name": "سالانه", "days": 365, "price_toman": 480000, "active": True},
            ],
            "payment_methods": {
                "rial": {
                    "enabled": True,
                    "cards": [
                        {"bank": "bank_keshavarzi", "number": "6037-7015-3115-9454"},
                        {"bank": "bank_saderat", "number": "6037-6917-6387-5937"}
                    ],
                    "owner": "account_owner"
                },
                "trx": {
                    "enabled": True,
                    "wallet": "TW5PeEfiPXEaYf6ibFrxFrxLSDSX7AVZX1",
                    "network": "TRC20",
                    "currency": "USDT"
                },
            },
            "payment_receiver": {"chat_id": MASTER_ADMIN_ID},
            "features": {
                "bot_enabled": True,
                "registration_enabled": True,
                "language_selection_enabled": True,
                "buy_coins_enabled": True,
                "coin_packages_enabled": True,
                "custom_coin_enabled": True,
                "manual_payment_enabled": True,
                "online_payment_enabled": False,
                "subscription_enabled": True,
                "subscription_plans_enabled": True,
                "add_product_enabled": True,
                "pin_product_enabled": True,
                "group_advertising_enabled": True,
                "price_inquiry_enabled": True,
                "inquiry_chart_enabled": True,
                "auctions_enabled": True,
                "auction_bidding_enabled": True,
                "auction_buy_now_enabled": True,
                "legal_consult_enabled": True,
                "lawyer_registration_enabled": True,
                "referral_enabled": True,
                "referral_bonus_enabled": True,
                "group_invite_enabled": True,
                "contests_enabled": True,
                "games_enabled": True,
                "marketplaces_enabled": True,
                "profile_enabled": True,
                "calendar_enabled": True,
                "search_enabled": True,
                "rules_enabled": True,
                "guide_enabled": True,
                "smart_response_enabled": True,
                "advanced_search_enabled": True,
                "rating_enabled": True,
                "rental_enabled": True,
                "scalability_mode": True,
                "archive_payments_enabled": True,
            },
            "search_settings": {
                "max_range_days": 365,
                "default_range_days": 30,
                "results_per_page": 10,
                "filters": ["keyword", "category", "date_range", "ad_type", "status", "rating", "location"]
            },
        }
    }

async def load_data():
    async with data_lock:
        if not os.path.exists(DATA_FILE):
            return default_data()
        try:
            async with aiofiles.open(DATA_FILE, "r", encoding="utf-8") as f:
                content = await f.read()
                data = json.loads(content) if content else default_data()
                default = default_data()
                for key in default:
                    if key not in data:
                        data[key] = default[key]
                for section in default["settings"]:
                    if section not in data["settings"]:
                        data["settings"][section] = default["settings"][section]
                return data
        except Exception as e:
            logger.error(f"خطا در بارگذاری داده: {e}")
            return default_data()

async def save_data(data):
    async with data_lock:
        try:
            async with aiofiles.open(DATA_FILE, "w", encoding="utf-8") as f:
                await f.write(json.dumps(data, indent=4, ensure_ascii=False))
        except Exception as e:
            logger.error(f"خطا در ذخیره داده: {e}")

# ==================== سیستم چندزبانه و بومی‌سازی ====================
LANGUAGES = {
    "fa": {"name": "فارسی", "emoji": "🇮🇷", "locale": "fa_IR", "calendar": "persian"},
    "en": {"name": "English", "emoji": "🇬🇧", "locale": "en_US", "calendar": "gregorian"},
    "ru": {"name": "Русский", "emoji": "🇷🇺", "locale": "ru_RU", "calendar": "gregorian"},
    "ur": {"name": "اردو", "emoji": "🇵🇰", "locale": "ur_PK", "calendar": "gregorian"},
    "hi": {"name": "हिन्दी", "emoji": "🇮🇳", "locale": "hi_IN", "calendar": "gregorian"},
    "fr": {"name": "Français", "emoji": "🇫🇷", "locale": "fr_FR", "calendar": "gregorian"},
    "de": {"name": "Deutsch", "emoji": "🇩🇪", "locale": "de_DE", "calendar": "gregorian"},
    "es": {"name": "Español", "emoji": "🇪🇸", "locale": "es_ES", "calendar": "gregorian"},
    "zh": {"name": "中文", "emoji": "🇨🇳", "locale": "zh_CN", "calendar": "gregorian"},
    "ar": {"name": "العربية", "emoji": "🇸🇦", "locale": "ar_SA", "calendar": "islamic"},
    "tr": {"name": "Türkçe", "emoji": "🇹🇷", "locale": "tr_TR", "calendar": "gregorian"},
}

# دیکشنری ترجمه (بخش اصلی) – برای جلوگیری از طولانی شدن، فقط کلیدهای جدید اضافه می‌شوند
TRANSLATIONS = {
    "fa": {
        "menu_title": "🏠 به تجارتخانه خوش آمدید!\n🪙 موجودی: {coins}\n📅 اشتراک: {subscription_status}",
        "buy_coins_btn": "🪙 خرید سکه",
        "invite_btn": "🤝 دعوت",
        "register_btn": "📋 ثبت‌نام",
        "guide_btn": "📖 راهنما",
        "my_coins": "🪙 موجودی: {coins}",
        "price_inquiry": "🔍 استعلام قیمت",
        "auctions": "⚡ مزایده",
        "add_product": "📦 آگهی جدید",
        "pin_product": "📌 پین آگهی",
        "contests": "🏆 مسابقات",
        "profile": "👤 پروفایل",
        "calendar": "📅 تقویم",
        "legal": "⚖️ حقوقی",
        "search": "🔎 جستجو",
        "public_groups": "🏪 بازارها",
        "rules": "📋 قوانین",
        "admin_panel": "👑 مدیریت",
        "language": "🌐 زبان",
        "back": "🔙 بازگشت",
        "access_denied": "❌ دسترسی غیرمجاز",
        "processing_error": "❌ خطا در پردازش. لطفاً دوباره تلاش کنید.",
        "not_enough_coins": "⛔ سکه کافی ندارید!",
        "not_enough_min_coins": "⛔ حداقل سکه مورد نیاز: {min_coins}",
        "receipt_sent": "✅ فیش ارسال شد. منتظر تأیید ادمین باشید.",
        "payment_approved": "✅ پرداخت {payment_id} تأیید شد. {coins} سکه اضافه شد.",
        "payment_rejected": "❌ پرداخت {payment_id} رد شد.",
        "subscription_activated": "✅ اشتراک {plan_name} تا {expiry_date} فعال شد.",
        "invite_link": "🎁 لینک دعوت:\n`{link}`",
        "free_coins_claimed": "🎁 ۵ سکه رایگان دریافت کردید!",
        "already_claimed": "⏳ امروز قبلاً دریافت کرده‌اید.",
        "guide_text": "📖 راهنمای کامل به زودی...",
        "my_coins_text": "🪙 موجودی: {coins} سکه",
        "profile_text": "👤 نام: {first_name}\n🪙 سکه: {coins}",
        "rules_text": """⚖️👨‍⚖️👩‍⚖️ قوانین و شرایط استفاده از «تجارتخانه بازار بزرگ ایران وجهان» 👨‍⚖️👩‍⚖️⚖️
🤝 توافق‌نامه عضویت و استفاده از خدمات 🤝
👋 کاربر گرامی،
عضویت، ورود و استفاده از خدمات «تجارتخانه بازار بزرگ ایران وجهان» به منزله مطالعه، آگاهی و پذیرش کامل شرایط، قوانین و مقررات این پلتفرم است. لطفاً پیش از استفاده از خدمات، مفاد زیر را با دقت مطالعه فرمایید.
━━━━━━━━━━━━━━━━━━
🏢 ۱. ماهیت پلتفرم
📌 «تجارتخانه بازار بزرگ ایران» صرفاً یک بستر مجازی برای معرفی کالاها، خدمات، تبلیغات و ایجاد ارتباط میان کاربران است.
📌 این پلتفرم در هیچ‌یک از معاملات، قراردادها، پرداخت‌ها، دریافت‌ها یا تعهدات میان کاربران، طرف معامله، نماینده، واسطه یا ضامن محسوب نمی‌شود.
━━━━━━━━━━━━━━━━━━
👤 ۲. مسئولیت محتوا و فعالیت کاربران
📢 مسئولیت کامل تمامی پیام‌ها، آگهی‌ها، تصاویر، فایل‌ها، اطلاعات و محتوای منتشرشده بر عهده منتشرکننده آن است.
⚠️ کاربران متعهد می‌شوند از انتشار هرگونه محتوای خلاف قانون، گمراه‌کننده، توهین‌آمیز، مجرمانه یا ناقض حقوق اشخاص خودداری نمایند.
━━━━━━━━━━━━━━━━━━
🤝 ۳. معاملات و ارتباطات کاربران
💼 تمامی مذاکرات، توافقات، خرید و فروش‌ها، پرداخت‌ها و تعهدات میان کاربران، صرفاً بر عهده طرفین معامله است.
⚠️ مسئولیت هرگونه کلاهبرداری، اختلاف، عدم انجام تعهدات، خسارات مالی، معنوی یا تجاری ناشی از ارتباط کاربران، بر عهده اشخاص مربوطه بوده و متوجه پلتفرم نخواهد بود.
━━━━━━━━━━━━━━━━━━
🔍 ۴. اعتبار و احراز هویت کاربران
📋 تجارتخانه هیچ‌گونه تضمین یا تأییدی نسبت به هویت، اعتبار، مجوزها، توانایی مالی یا حسن انجام تعهدات کاربران ارائه نمی‌دهد.
🤝 بررسی سوابق، اعتبار و اطمینان از طرف معامله، بر عهده کاربران است.
━━━━━━━━━━━━━━━━━━
🪙 ۵. سکه‌ها و اعتبارات دیجیتال
💳 سکه‌ها و اعتبارات خریداری‌شده صرفاً جهت استفاده از خدمات داخلی پلتفرم می‌باشند.
📌 پس از خرید و تخصیص اعتبار به حساب کاربری، امکان استرداد، تبدیل به وجه نقد یا مطالبه وجه وجود ندارد؛ مگر در مواردی که قوانین جمهوری اسلامی ایران الزام کرده باشد.
━━━━━━━━━━━━━━━━━━
🚫 ۶. محتوای ممنوعه
انتشار، تبلیغ یا ترویج موارد زیر ممنوع است:
❌ محتوای مجرمانه یا مغایر با قوانین کشور
❌ توهین، افترا، تهدید و نشر اکاذیب
❌ محتوای سیاسی، مذهبی یا فرهنگی تنش‌زا
❌ مواد مخدر، روان‌گردان‌ها، سلاح و مهمات
❌ خرید و فروش غیرقانونی حیوانات وحشی
❌ کالاها و خدمات غیرمجاز یا ممنوعه
❌ هرگونه فعالیت مغایر با قوانین جمهوری اسلامی ایران
⚖️ مسئولیت حقوقی و کیفری این موارد مستقیماً بر عهده منتشرکننده محتوا خواهد بود.
━━━━━━━━━━━━━━━━━━
⚙️ ۷. اختلالات و محدودیت‌های خارج از کنترل
🌐 پلتفرم همواره در تلاش برای ارائه خدمات پایدار است؛ با این حال در صورت بروز:
🔹 اختلالات فنی
🔹 قطعی یا محدودیت اینترنت
🔹 حملات سایبری
🔹 دستورات مراجع قضایی و قانونی
🔹 حوادث غیرمترقبه و شرایط خارج از کنترل
هیچ‌گونه مسئولیتی متوجه مالک، مدیران و عوامل اجرایی پلتفرم نخواهد بود.
━━━━━━━━━━━━━━━━━━
🛡️ ۸. حق نظارت و مدیریت
📌 تجارتخانه حق دارد در صورت مشاهده تخلف، نقض قوانین یا سوءاستفاده از خدمات، نسبت به:
🔹 حذف محتوا
🔹 محدودسازی دسترسی
🔹 تعلیق یا مسدودسازی حساب کاربری
اقدام نماید.
⚖️ این اقدامات مانع از پیگیری موضوع از طریق مراجع قانونی نخواهد بود.
━━━━━━━━━━━━━━━━━━
🇮🇷 ۹. قانون حاکم
📚 تمامی فعالیت‌ها و خدمات این پلتفرم تابع قوانین و مقررات جمهوری اسلامی ایران از جمله قوانین تجارت الکترونیکی، جرائم رایانه‌ای و سایر مقررات مرتبط است.
🏛️ رسیدگی به اختلافات احتمالی در صلاحیت مراجع قانونی و قضایی جمهوری اسلامی ایران خواهد بود.
━━━━━━━━━━━━━━━━━━
✅ تأیید و پذیرش کاربر
✍️ کاربر با عضویت، ورود، استفاده از خدمات یا انتخاب گزینه «می‌پذیرم»، اعلام می‌نماید که:
☑️ مفاد این توافق‌نامه را به‌طور کامل مطالعه کرده است.
☑️ از آثار حقوقی و تعهدات ناشی از آن آگاهی دارد.
☑️ تمامی شرایط و مقررات فوق را پذیرفته و ملزم به رعایت آن‌ها می‌باشد.
━━━━━━━━━━━━━━━━━━
🌹🙏 از اعتماد و همراهی شما سپاسگزاریم 🙏🌹
👨‍💼🏢 مدیریت «تجارتخانه بازار بزرگ ایران و جهان » 🏢👨‍💼
⚖️ «شفافیت، مسئولیت‌پذیری و تجارت سالم؛ زیربنای اعتماد پایدار» ⚖️
‌""",
        "product_form_desc": "📝 **فرم ثبت آگهی**\nنام:\nتوضیحات:\nقیمت (تومان):\nدسته‌بندی:\nتعداد/مقدار:\nواحد:",
        "product_form_success": "✅ آگهی شما با شناسه {id} ثبت شد.",
        "product_form_fail": "❌ فرمت نامعتبر. لطفاً تمام فیلدها را پر کنید.",
        "choose_package": "💰 **خرید سکه**\nهر ۱ سکه = {price_per_coin:,} تومان / {price_foreign:.2f} {foreign_currency_symbol}",
        "custom_coin": "✏️ تعداد دلخواه",
        "package_btn": "{coins} سکه",
        "coin_purchase_summary": "خرید {coins} سکه\n💰 جمع: {price:,} تومان / {price_foreign_total:.2f} {foreign_currency_symbol}",
        "pay_card_btn": "💳 کارت به کارت",
        "pay_trx_btn": "💳 پرداخت با تتر (TRC20)",
        "custom_coin_prompt": "✏️ تعداد سکه (۱ تا ۱۰۰۰۰):",
        "custom_coin_confirm": "🪙 تعداد: {amount}\n💰 کل: {total_price:,} تومان",
        "confirm_purchase_btn": "✅ تأیید و خرید",
        "cancel_btn": "❌ انصراف",
        "payment_card_detail": "➕ خرید {coins} سکه\n💰 هر سکه = {price_per_coin:,} تومان\n💸 کل: {price:,} تومان\n🏦 شماره کارت‌ها:\n{cards_text}\n👤 به نام: {owner}",
        "payment_trx_detail": "➕ خرید {coins} سکه\n💰 هر سکه = {price_per_coin:,} تومان\n💸 کل: {price:,} تومان\n💳 آدرس ولت TRC20:\n`{wallet}`\nشبکه: {network}",
        "admin_panel_text": "👑 پنل مدیریت\n📨 درخواست‌های در انتظار: {pending_count}",
        "no_pending_payments": "📭 هیچ درخواست پرداختی در انتظار نیست.",
        "pending_payments_list": "📨 **درخواست‌های پرداخت**\n{list_text}",
        "subscription_plans_text": "📅 پلن‌های اشتراک:\n{plans_text}",
        "invite_link": "🎁 لینک دعوت:\n`{link}`",
        "free_coins_claimed": "🎁 ۵ سکه رایگان گرفتید!",
        "already_claimed": "⏳ امروز گرفتید.",
        "guide_text": "📖 راهنمای کامل به زودی...",
        "my_coins_text": "🪙 موجودی: {coins} سکه",
        "profile_text": "👤 نام: {first_name}\n🪙 سکه: {coins}",
        "public_groups_text": "🏪 بازارهای تخصصی به زودی...",
        "auctions_text": "⚡ مزایده‌ها به زودی...",
        "pin_product_text": "📌 پین آگهی به زودی...",
        "contests_text": "🏆 مسابقات به زودی...",
        "calendar_text": "📅 تقویم رویدادها...",
        "legal_text": "⚖️ مشاوره حقوقی به زودی...",
        "search_prompt": "🔎 عبارت جستجو را وارد کنید:",
        "register_text": "📋 ثبت‌نام حرفه‌ای به زودی...",
        "stats_text": "📊 آمار:\n👥 کاربران: {users_count}",
        "income_model_text": "💰 مدل فعلی: {current}",
        "income_model_coin": "💰 سکه",
        "income_model_subscription": "📅 اشتراک",
        "income_model_both": "💰📅 هر دو",
        "features_text": "⚙️ قابلیت‌ها:\n{features_list}",
        "feature_toggled": "✅ {feature_key} = {status}",
        "coin_packages_list": "📦 **بسته‌های فعلی:**\n{packages_list}",
        "add_package_prompt": "➕ **افزودن بسته جدید**\nفرمت: `تعداد - قیمت`\nمثال: `50 - 1250000`",
        "remove_package_prompt": "🗑️ **حذف بسته**\nشناسه بسته را وارد کنید:",
        "toggle_package_prompt": "🔁 **فعال/غیرفعال بسته**\nشناسه بسته را وارد کنید:",
        "subscription_plans_list": "📅 پلن‌ها:\n{plans_list}",
        "transactions_list": "📋 تراکنش‌ها:\n{transactions_list}",
        "subscriptions_list": "📋 اشتراک‌ها:\n{subs_list}",
        "manual_sub_prompt": "➕ فرمت: user_id - plan_id",
        "payment_methods_text": "💳 روش‌های پرداخت:\n{methods_list}",
        "set_receiver_prompt": "📨 آیدی دریافت‌کننده را وارد کنید:",
        "set_coin_price_prompt": "🪙 **قیمت هر سکه**\nقیمت فعلی: {current_price:,} تومان / {current_foreign:.2f} {foreign_currency_symbol}",
        "set_min_coins_prompt": "🔹 **حداقل سکه برای آگهی**\nمقدار فعلی: {current} سکه",
        "set_cost_prompt": "{label}\nمقدار فعلی: {current} سکه",
        "setting_updated": "✅ تنظیم به‌روزرسانی شد.",
        "invalid_number": "❌ لطفاً یک عدد معتبر وارد کنید.",
        "positive_number": "❌ مقدار باید مثبت باشد.",
        "coin_price_min_error": "❌ قیمت باید حداقل ۱۰۰۰ تومان باشد.",
        "coin_price_updated": "✅ قیمت سکه به {new_price:,} تومان تغییر یافت.",
        "package_added": "✅ بسته {coins} سکه = {price:,} تومان اضافه شد.",
        "package_removed": "✅ بسته {coins} سکه حذف شد.",
        "package_toggled": "✅ وضعیت بسته {coins} سکه به {status} تغییر کرد.",
        "package_not_found": "❌ بسته‌ای با این شناسه پیدا نشد.",
        "invalid_format": "❌ فرمت نامعتبر. مثال: `50 - 125000`",
        "manual_sub_success": "✅ اشتراک برای {target_user} فعال شد.",
        "manual_sub_error": "❌ فرمت: user_id - plan_id",
        "receiver_updated": "✅ دریافت‌کننده به‌روزرسانی شد.",
        "receipt_required": "❌ لطفاً تصویر فیش را ارسال کنید.",
        "ad_registration_report": "✅ **آگهی ثبت شد!**\n• نام: {name}\n• قیمت: {price} تومان\n• هزینه: {cost} سکه\n• موجودی قبلی: {old_coins}\n• موجودی فعلی: {new_coins}",
        "admin_pending_btn": "📨 تأیید پرداخت‌ها ({count})",
        "confirm_btn": "✅ تأیید {id}",
        "reject_btn": "❌ رد {id}",
        "language_menu_title": "🌐 **انتخاب زبان / Select Language**",
        "language_changed": "✅ زبان شما به {lang_name} تغییر یافت.",
        "bank_keshavarzi": "بانک کشاورزی",
        "bank_saderat": "بانک صادرات",
        "account_owner": "محمدرضا حبیبی",
        "card_number_prefix": "شماره کارت",
        # کلیدهای جدید
        "inquiry_form_title": "📝 **فرم استعلام قیمت**\nلطفاً مشخصات کالا را وارد کنید:",
        "inquiry_submit": "✅ استعلام شما با موفقیت ارسال شد.",
        "inquiry_expired": "⏳ زمان استعلام به پایان رسیده است.",
        "inquiry_no_bids": "هنوز هیچ قیمتی ثبت نشده است.",
        "inquiry_chart": "📊 **نمودار قیمت‌ها**\nپایین‌ترین: {lowest}\nبالاترین: {highest}\nمیانگین: {avg}\nتعداد: {count}",
        "bid_placed": "✅ پیشنهاد شما با مبلغ {price} ثبت شد.",
        "bid_suspicious": "⚠️ قیمت شما با میانگین فعلی تفاوت زیادی دارد. آیا مطمئن هستید؟",
        "auction_form_title": "📝 **فرم ثبت مزایده**\nلطفاً اطلاعات کالا را وارد کنید:",
        "auction_created": "✅ مزایده با شناسه {id} ثبت شد.",
        "auction_ended": "🏆 مزایده {title} به پایان رسید.\nبرنده: {winner}\nقیمت نهایی: {final_price}",
        "lawyer_reg_form": "📝 **فرم ثبت‌نام وکیل**\nنام و نام خانوادگی:\nشماره پروانه:\nتخصص:\nشماره تماس:\nشناسه تلگرام:\nتوضیحات (اختیاری):",
        "lawyer_reg_success": "✅ ثبت‌نام وکیل با موفقیت انجام شد. منتظر تأیید ادمین باشید.",
        "lawyer_activated": "✅ وکیل {name} فعال شد.",
        "lawyer_expired": "⏳ اشتراک وکیل {name} منقضی شد.",
        "legal_consult_request": "⚖️ درخواست مشاوره حقوقی\nلطفاً موضوع را به‌اختصار وارد کنید:",
        "legal_consult_assigned": "✅ وکیل {name} به شما اختصاص داده شد.\nشماره تماس: {phone}\nشناسه تلگرام: {telegram_id}\nتوضیحات: {bio}",
        "game_menu": "🎮 **بازی و سرگرمی**\nیک بازی را انتخاب کنید:",
        "game_guess_number": "🔢 **حدس عدد**\nیک عدد بین ۱ تا ۱۰۰ حدس بزنید.",
        "game_guess_result": "🎯 {result}!\nعدد {number} بود.",
        "game_dice": "🎲 **تاس شانس**\nشما عدد {number} آوردید.\nجایزه: {prize} سکه",
        "market_list_title": "🏪 **لیست بازارهای تجارتخانه**\nصفحه {page} از {total}",
        "market_join": "✅ به بازار {name} پیوستید.",
        "profile_edit": "✏️ **ویرایش پروفایل**\nبخشی را که می‌خواهید ویرایش کنید انتخاب کنید:",
        "profile_updated": "✅ اطلاعات شما با موفقیت به‌روزرسانی شد.",
        "rating_prompt": "⭐ **امتیازدهی به فروشنده**\nچند ستاره به {name} می‌دهید؟ (۱ تا ۵)",
        "rating_thanks": "✅ از امتیاز شما سپاسگزاریم!",
        "rental_request_form": "🏢 **درخواست اجاره ربات**\nلطفاً اطلاعات گروه را وارد کنید:\nنام گروه:\nلینک گروه:\nتعداد اعضا (تقریبی):",
        "rental_request_sent": "✅ درخواست شما به ادمین ارسال شد.",
        "rental_approved": "✅ اجاره گروه {group} تأیید شد. تا {expiry} فعال است.",
        "rental_expired": "⏳ اشتراک گروه {group} منقضی شد. لطفاً تمدید کنید.",
        "rental_payment_reminder": "⏰ **یادآوری تمدید اشتراک**\nاشتراک گروه {group} در {days} روز آینده منقضی می‌شود.",
        "search_results": "🔎 **نتایج جستجو** ({count} مورد):\n{results}",
        "search_no_results": "❌ هیچ نتیجه‌ای یافت نشد.",
        "smart_response": "🤖 **پاسخ هوشمند:**\n{response}",
        # کلیدهای جدید برای مدیریت کاربران
        "user_management_menu": "👤 **مدیریت کاربران**\nلطفاً شناسه یا نام کاربر را وارد کنید:",
        "user_not_found": "❌ کاربری با این مشخصات یافت نشد.",
        "user_profile_info": "👤 **پروفایل کاربر**\nشناسه: {user_id}\nنام: {name}\nسکه: {coins}\nاشتراک: {subscription}\nتاریخ عضویت: {joined}\nتعداد آگهی: {ads}",
        "user_coins_updated": "✅ موجودی سکه کاربر {user_id} به {new_coins} تغییر یافت.",
        "user_subscription_updated": "✅ اشتراک کاربر {user_id} به‌روزرسانی شد.",
        "broadcast_prompt": "📨 **ارسال پیام گروهی**\nلطفاً متن پیام را وارد کنید:",
        "broadcast_sent": "✅ پیام به {groups} گروه و {users} کاربر ارسال شد.",
        "broadcast_failed": "❌ خطا در ارسال پیام گروهی.",
        "promote_demote_menu": "🔄 **تغییر نقش کاربر در گروه**\nشناسه کاربر و گروه را وارد کنید:\nفرمت: user_id - group_id",
        "promote_success": "✅ کاربر {user_id} در گروه {group_id} به ادمین ارتقا یافت.",
        "demote_success": "✅ ادمین {user_id} در گروه {group_id} به کاربر عادی تبدیل شد.",
        "role_change_error": "❌ خطا در تغییر نقش. مطمئن شوید ربات ادمین گروه است.",
        "private_message_prompt": "💬 **ارسال پیام خصوصی به کاربر**\nشناسه کاربر و متن پیام را وارد کنید:\nفرمت: user_id - متن",
        "private_message_sent": "✅ پیام به کاربر {user_id} ارسال شد.",
        "private_message_failed": "❌ خطا در ارسال پیام.",
    },
    # سایر زبان‌ها مشابه فارسی ترجمه می‌شوند (برای اختصار فقط انگلیسی نمونه)
    "en": {
        "menu_title": "🏠 Welcome to Trade House!\n🪙 Balance: {coins}\n📅 Subscription: {subscription_status}",
        "buy_coins_btn": "🪙 Buy Coins",
        "invite_btn": "🤝 Invite",
        "register_btn": "📋 Register",
        "guide_btn": "📖 Guide",
        "my_coins": "🪙 Balance: {coins}",
        "price_inquiry": "🔍 Price Inquiry",
        "auctions": "⚡ Auctions",
        "add_product": "📦 New Ad",
        "pin_product": "📌 Pin Ad",
        "contests": "🏆 Contests",
        "profile": "👤 Profile",
        "calendar": "📅 Calendar",
        "legal": "⚖️ Legal",
        "search": "🔎 Search",
        "public_groups": "🏪 Markets",
        "rules": "📋 Rules",
        "admin_panel": "👑 Admin",
        "language": "🌐 Language",
        "back": "🔙 Back",
        "access_denied": "❌ Access denied.",
        "processing_error": "❌ Processing error. Please try again.",
        "not_enough_coins": "⛔ Not enough coins!",
        "not_enough_min_coins": "⛔ Minimum coins required: {min_coins}",
        "receipt_sent": "✅ Receipt sent. Waiting for admin approval.",
        "payment_approved": "✅ Payment {payment_id} approved. {coins} coins added.",
        "payment_rejected": "❌ Payment {payment_id} rejected.",
        "subscription_activated": "✅ Subscription {plan_name} activated until {expiry_date}.",
        "invite_link": "🎁 Invite link:\n`{link}`",
        "free_coins_claimed": "🎁 You got 5 free coins!",
        "already_claimed": "⏳ Already claimed today.",
        "guide_text": "📖 Full guide coming soon...",
        "my_coins_text": "🪙 Balance: {coins} coins",
        "profile_text": "👤 Name: {first_name}\n🪙 Coins: {coins}",
        "rules_text": "📋 Group rules... (translated version)",
        "public_groups_text": "🏪 Specialized markets coming soon...",
        "auctions_text": "⚡ Auctions coming soon...",
        "pin_product_text": "📌 Pin ad coming soon...",
        "contests_text": "🏆 Contests coming soon...",
        "calendar_text": "📅 Events calendar...",
        "legal_text": "⚖️ Legal consultation coming soon...",
        "search_prompt": "🔎 Enter search term:",
        "register_text": "📋 Professional registration coming soon...",
        "stats_text": "📊 Statistics:\n👥 Users: {users_count}",
        "income_model_text": "💰 Current model: {current}",
        "income_model_coin": "💰 Coin",
        "income_model_subscription": "📅 Subscription",
        "income_model_both": "💰📅 Both",
        "features_text": "⚙️ Features:\n{features_list}",
        "feature_toggled": "✅ {feature_key} = {status}",
        "coin_packages_list": "📦 **Current Packages:**\n{packages_list}",
        "add_package_prompt": "➕ **Add Package**\nFormat: `coins - price`\nExample: `50 - 1250000`",
        "remove_package_prompt": "🗑️ **Remove Package**\nEnter package ID:",
        "toggle_package_prompt": "🔁 **Toggle Package**\nEnter package ID:",
        "subscription_plans_list": "📅 Plans:\n{plans_list}",
        "transactions_list": "📋 Transactions:\n{transactions_list}",
        "subscriptions_list": "📋 Subscriptions:\n{subs_list}",
        "manual_sub_prompt": "➕ Format: user_id - plan_id",
        "payment_methods_text": "💳 Payment Methods:\n{methods_list}",
        "set_receiver_prompt": "📨 Enter receiver ID:",
        "set_coin_price_prompt": "🪙 **Coin Price**\nCurrent: {current_price:,} Toman / {current_foreign:.2f} {foreign_currency_symbol}",
        "set_min_coins_prompt": "🔹 **Min coins for ad**\nCurrent: {current} coins",
        "set_cost_prompt": "{label}\nCurrent: {current} coins",
        "setting_updated": "✅ Setting updated.",
        "invalid_number": "❌ Please enter a valid number.",
        "positive_number": "❌ Value must be positive.",
        "coin_price_min_error": "❌ Price must be at least 1000 Toman.",
        "coin_price_updated": "✅ Coin price changed to {new_price:,} Toman.",
        "package_added": "✅ Package {coins} coins = {price:,} Toman added.",
        "package_removed": "✅ Package {coins} coins removed.",
        "package_toggled": "✅ Package {coins} coins status changed to {status}.",
        "package_not_found": "❌ Package not found.",
        "invalid_format": "❌ Invalid format. Example: `50 - 125000`",
        "manual_sub_success": "✅ Subscription activated for {target_user}.",
        "manual_sub_error": "❌ Format: user_id - plan_id",
        "receiver_updated": "✅ Receiver updated.",
        "receipt_required": "❌ Please send a receipt image.",
        "ad_registration_report": "✅ **Ad registered!**\n• Name: {name}\n• Price: {price} Toman\n• Cost: {cost} coins\n• Previous balance: {old_coins}\n• New balance: {new_coins}",
        "admin_pending_btn": "📨 Pending Payments ({count})",
        "confirm_btn": "✅ Approve {id}",
        "reject_btn": "❌ Reject {id}",
        "language_menu_title": "🌐 **Select Language**",
        "language_changed": "✅ Language changed to {lang_name}.",
        "bank_keshavarzi": "Keshavarzi Bank",
        "bank_saderat": "Saderat Bank",
        "account_owner": "Mohammad Reza Habibi",
        "card_number_prefix": "Card Number",
        # new keys
        "inquiry_form_title": "📝 **Price Inquiry Form**\nPlease enter product details:",
        "inquiry_submit": "✅ Inquiry submitted successfully.",
        "inquiry_expired": "⏳ Inquiry time has expired.",
        "inquiry_no_bids": "No prices registered yet.",
        "inquiry_chart": "📊 **Price Chart**\nLowest: {lowest}\nHighest: {highest}\nAverage: {avg}\nCount: {count}",
        "bid_placed": "✅ Your bid of {price} was placed.",
        "bid_suspicious": "⚠️ Your price differs significantly from the average. Are you sure?",
        "auction_form_title": "📝 **Auction Registration Form**\nPlease enter product details:",
        "auction_created": "✅ Auction with ID {id} created.",
        "auction_ended": "🏆 Auction {title} ended.\nWinner: {winner}\nFinal price: {final_price}",
        "lawyer_reg_form": "📝 **Lawyer Registration Form**\nFull name:\nBar number:\nSpecialty:\nPhone:\nTelegram ID:\nBio (optional):",
        "lawyer_reg_success": "✅ Lawyer registration successful. Awaiting admin approval.",
        "lawyer_activated": "✅ Lawyer {name} activated.",
        "lawyer_expired": "⏳ Lawyer {name} subscription expired.",
        "legal_consult_request": "⚖️ Legal consultation request.\nPlease briefly describe your issue:",
        "legal_consult_assigned": "✅ Lawyer {name} assigned to you.\nPhone: {phone}\nTelegram: {telegram_id}\nBio: {bio}",
        "game_menu": "🎮 **Games & Fun**\nChoose a game:",
        "game_guess_number": "🔢 **Guess the Number**\nGuess a number between 1 and 100.",
        "game_guess_result": "🎯 {result}!\nThe number was {number}.",
        "game_dice": "🎲 **Lucky Dice**\nYou rolled {number}.\nPrize: {prize} coins",
        "market_list_title": "🏪 **Market List**\nPage {page} of {total}",
        "market_join": "✅ Joined market {name}.",
        "profile_edit": "✏️ **Edit Profile**\nSelect the section to edit:",
        "profile_updated": "✅ Profile updated successfully.",
        "rating_prompt": "⭐ **Rate Seller**\nHow many stars to {name}? (1-5)",
        "rating_thanks": "✅ Thank you for your rating!",
        "rental_request_form": "🏢 **Rental Request**\nPlease enter group details:\nGroup name:\nGroup link:\nApproximate members:",
        "rental_request_sent": "✅ Request sent to admin.",
        "rental_approved": "✅ Rental for group {group} approved. Active until {expiry}.",
        "rental_expired": "⏳ Group {group} subscription expired. Please renew.",
        "rental_payment_reminder": "⏰ **Renewal Reminder**\nGroup {group} subscription expires in {days} days.",
        "search_results": "🔎 **Search Results** ({count} items):\n{results}",
        "search_no_results": "❌ No results found.",
        "smart_response": "🤖 **Smart Response:**\n{response}",
        "user_management_menu": "👤 **User Management**\nEnter user ID or name:",
        "user_not_found": "❌ User not found.",
        "user_profile_info": "👤 **User Profile**\nID: {user_id}\nName: {name}\nCoins: {coins}\nSubscription: {subscription}\nJoined: {joined}\nAds: {ads}",
        "user_coins_updated": "✅ User {user_id} coins updated to {new_coins}.",
        "user_subscription_updated": "✅ User {user_id} subscription updated.",
        "broadcast_prompt": "📨 **Broadcast Message**\nEnter the message text:",
        "broadcast_sent": "✅ Message sent to {groups} groups and {users} users.",
        "broadcast_failed": "❌ Failed to send broadcast.",
        "promote_demote_menu": "🔄 **Change User Role in Group**\nFormat: user_id - group_id",
        "promote_success": "✅ User {user_id} promoted to admin in group {group_id}.",
        "demote_success": "✅ Admin {user_id} demoted to member in group {group_id}.",
        "role_change_error": "❌ Role change error. Make sure bot is admin in the group.",
        "private_message_prompt": "💬 **Send Private Message**\nFormat: user_id - message",
        "private_message_sent": "✅ Message sent to user {user_id}.",
        "private_message_failed": "❌ Failed to send message.",
    }
}

def get_text(lang, key, **kwargs):
    if lang not in TRANSLATIONS:
        lang = "en"
    text = TRANSLATIONS.get(lang, {}).get(key, key)
    try:
        return text.format(**kwargs)
    except KeyError:
        return text

def get_user_lang(data, user_id):
    return data.get("user_langs", {}).get(str(user_id), "fa")

def set_user_lang(data, user_id, lang):
    if "user_langs" not in data:
        data["user_langs"] = {}
    data["user_langs"][str(user_id)] = lang

def generate_id():
    return datetime.now().strftime("%Y%m%d%H%M%S") + str(random.randint(1000, 9999))

def format_datetime(dt, lang_code, format_type="full"):
    lang_info = LANGUAGES.get(lang_code, LANGUAGES["en"])
    locale = lang_info["locale"]
    if lang_code == "fa":
        jd = jdatetime.datetime.fromgregorian(datetime=dt)
        if format_type == "date":
            return jd.strftime("%Y/%m/%d")
        elif format_type == "time":
            return jd.strftime("%H:%M")
        elif format_type == "full":
            return jd.strftime("%A %d %B %Y، ساعت %H:%M")
        elif format_type == "relative":
            return _relative_time_fa(dt)
    elif lang_code == "ar":
        return format_datetime(dt, locale='ar_SA', format='full' if format_type=='full' else 'short')
    else:
        if format_type == "date":
            return format_date(dt, locale=locale)
        elif format_type == "time":
            return format_time(dt, locale=locale)
        elif format_type == "full":
            return format_datetime(dt, locale=locale)
        elif format_type == "relative":
            return _relative_time_en(dt)
    return str(dt)

def _relative_time_fa(dt):
    now = datetime.now()
    diff = now - dt
    seconds = diff.total_seconds()
    if seconds < 60:
        return "چند لحظه پیش"
    elif seconds < 3600:
        return f"{int(seconds//60)} دقیقه پیش"
    elif seconds < 86400:
        return f"{int(seconds//3600)} ساعت پیش"
    elif seconds < 604800:
        return f"{int(seconds//86400)} روز پیش"
    else:
        return format_datetime(dt, "fa", "date")

def _relative_time_en(dt):
    now = datetime.now()
    diff = now - dt
    seconds = diff.total_seconds()
    if seconds < 60:
        return "just now"
    elif seconds < 3600:
        return f"{int(seconds//60)} minutes ago"
    elif seconds < 86400:
        return f"{int(seconds//3600)} hours ago"
    elif seconds < 604800:
        return f"{int(seconds//86400)} days ago"
    else:
        return format_datetime(dt, "en", "date")

# ==================== منوها ====================
def get_main_menu(lang):
    return [
        [InlineKeyboardButton(get_text(lang, "buy_coins_btn"), callback_data="buy_coins")],
        [InlineKeyboardButton(get_text(lang, "invite_btn"), callback_data="invite")],
        [InlineKeyboardButton(get_text(lang, "register_btn"), callback_data="register"),
         InlineKeyboardButton(get_text(lang, "guide_btn"), callback_data="guide")],
        [InlineKeyboardButton(get_text(lang, "my_coins"), callback_data="my_coins"),
         InlineKeyboardButton(get_text(lang, "price_inquiry"), callback_data="price_inquiry")],
        [InlineKeyboardButton(get_text(lang, "auctions"), callback_data="auctions"),
         InlineKeyboardButton(get_text(lang, "add_product"), callback_data="add_product")],
        [InlineKeyboardButton(get_text(lang, "pin_product"), callback_data="pin_product"),
         InlineKeyboardButton(get_text(lang, "contests"), callback_data="contests")],
        [InlineKeyboardButton(get_text(lang, "profile"), callback_data="profile"),
         InlineKeyboardButton(get_text(lang, "calendar"), callback_data="calendar")],
        [InlineKeyboardButton(get_text(lang, "legal"), callback_data="legal"),
         InlineKeyboardButton(get_text(lang, "search"), callback_data="search")],
        [InlineKeyboardButton(get_text(lang, "public_groups"), callback_data="public_groups"),
         InlineKeyboardButton(get_text(lang, "rules"), callback_data="rules")],
        [InlineKeyboardButton(get_text(lang, "admin_panel"), callback_data="admin_panel")],
        [InlineKeyboardButton("🌐 Language / زبان", callback_data="language")],
    ]

def get_back_button(lang):
    return [[InlineKeyboardButton(get_text(lang, "back"), callback_data="menu")]]

def get_admin_main_menu(lang):
    return [
        [InlineKeyboardButton("📊 داشبورد و آمار", callback_data="admin_dashboard")],
        [InlineKeyboardButton("👥 مدیریت کاربران", callback_data="admin_users_menu")],
        [InlineKeyboardButton("🪙 مدیریت سکه و پرداخت", callback_data="admin_coins_menu")],
        [InlineKeyboardButton("📅 مدیریت اشتراک", callback_data="admin_subs_menu")],
        [InlineKeyboardButton("📦 مدیریت آگهی و بازار", callback_data="admin_ads_menu")],
        [InlineKeyboardButton("⚖️ مدیریت حقوقی", callback_data="admin_legal_menu")],
        [InlineKeyboardButton("🎮 مدیریت بازی‌ها", callback_data="admin_games_menu")],
        [InlineKeyboardButton("⚙️ مدیریت قابلیت‌ها", callback_data="admin_features_menu")],
        [InlineKeyboardButton("🖌️ مدیریت ظاهر", callback_data="admin_appearance_menu")],
        [InlineKeyboardButton("📨 درخواست‌های در انتظار", callback_data="admin_pending_payments")],
        [InlineKeyboardButton("📨 پیگیری فیش‌ها", callback_data="admin_track_payments")],
        [InlineKeyboardButton("📨 ارسال پیام گروهی", callback_data="admin_broadcast")],
        [InlineKeyboardButton("🔄 تغییر نقش کاربر در گروه", callback_data="admin_role_menu")],
        [InlineKeyboardButton("🏠 بازگشت به کاربر", callback_data="menu")],
    ]

def get_admin_users_menu(lang):
    return [
        [InlineKeyboardButton("🔍 جستجوی کاربر", callback_data="admin_find_user")],
        [InlineKeyboardButton("💬 ارسال پیام خصوصی", callback_data="admin_private_msg")],
        [InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")],
    ]

# ==================== توابع کمکی ====================
async def get_all_groups(data):
    """دریافت لیست تمام گروه‌های موجود از بازارها و اجاره‌ها"""
    groups = []
    for m in data.get("marketplaces", {}).values():
        if m.get("link"):
            # استخراج شناسه گروه از لینک (اگر ممکن باشد)
            pass
    for r in data.get("rentals", {}).values():
        if r.get("group_id"):
            groups.append(r["group_id"])
    return groups

# ==================== هندلرهای اصلی ====================
async def start(update, context):
    user_id = str(update.effective_user.id)
    data = await load_data()
    if user_id not in data["users"]:
        data["users"][user_id] = {
            "coins": 10,
            "first_name": update.effective_user.first_name or "کاربر",
            "joined": datetime.now().isoformat(),
            "invited_users": [],
            "total_invites": 0,
            "last_free_claim": None,
            "products": [],
            "registered": False,
            "profile": {}
        }
        await save_data(data)
    lang = get_user_lang(data, user_id)
    coins = data["users"][user_id].get("coins", 0)
    sub_status = "❌ غیرفعال"
    if user_id in data["subscriptions"]:
        expiry = data["subscriptions"][user_id].get("expiry")
        if expiry and datetime.fromisoformat(expiry) > datetime.now():
            sub_status = "✅ فعال"
    text = get_text(lang, "menu_title", coins=coins, subscription_status=sub_status)
    await update.message.reply_text(text, reply_markup=InlineKeyboardMarkup(get_main_menu(lang)), parse_mode="Markdown")

# ==================== Callback Handler ====================
async def button_handler(update, context):
    query = update.callback_query
    await query.answer()
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    callback = query.data

    if callback == "menu":
        coins = data["users"].get(user_id, {}).get("coins", 0)
        sub_status = "❌ غیرفعال"
        if user_id in data["subscriptions"]:
            expiry = data["subscriptions"][user_id].get("expiry")
            if expiry and datetime.fromisoformat(expiry) > datetime.now():
                sub_status = "✅ فعال"
        text = get_text(lang, "menu_title", coins=coins, subscription_status=sub_status)
        await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(get_main_menu(lang)), parse_mode="Markdown")

    elif callback == "buy_coins":
        await buy_coins(update, context)

    elif callback.startswith("coin_pkg_"):
        await coin_package_selected(update, context)

    elif callback == "custom_coin":
        await custom_coin_request(update, context)

    elif callback == "confirm_custom_coin":
        await confirm_custom_coin(update, context)

    elif callback == "pay_card":
        await pay_card(update, context)

    elif callback == "pay_trx":
        await pay_trx(update, context)

    elif callback == "invite":
        await invite(update, context)

    elif callback == "free_coins":
        await free_coins(update, context)

    elif callback == "guide":
        await guide(update, context)

    elif callback == "my_coins":
        await my_coins(update, context)

    elif callback == "profile":
        await profile(update, context)

    elif callback == "rules":
        await rules(update, context)

    elif callback == "public_groups":
        await public_groups(update, context)

    elif callback == "add_product":
        await add_product(update, context)

    elif callback == "price_inquiry":
        await price_inquiry(update, context)

    elif callback == "auctions":
        await auctions(update, context)

    elif callback == "pin_product":
        await pin_product(update, context)

    elif callback == "contests":
        await contests(update, context)

    elif callback == "calendar":
        await calendar(update, context)

    elif callback == "legal":
        await legal_consult(update, context)

    elif callback == "search":
        await search(update, context)

    elif callback == "register":
        await register(update, context)

    elif callback == "admin_panel":
        await admin_panel(update, context)

    elif callback == "admin_coins_menu":
        await query.edit_message_text("🪙 **مدیریت سکه**", reply_markup=InlineKeyboardMarkup(get_admin_coins_menu(lang)), parse_mode="Markdown")

    elif callback == "admin_subs_menu":
        await query.edit_message_text("📅 **مدیریت اشتراک**", reply_markup=InlineKeyboardMarkup(get_admin_subs_menu(lang)), parse_mode="Markdown")

    elif callback == "admin_ads_menu":
        await query.edit_message_text("📦 **مدیریت آگهی و بازار**", reply_markup=InlineKeyboardMarkup(get_admin_ads_menu(lang)), parse_mode="Markdown")

    elif callback == "admin_legal_menu":
        await query.edit_message_text("⚖️ **مدیریت حقوقی**", reply_markup=InlineKeyboardMarkup(get_admin_legal_menu(lang)), parse_mode="Markdown")

    elif callback == "admin_features_menu":
        await admin_features(update, context)

    elif callback.startswith("toggle_feat_"):
        await toggle_feature(update, context)

    elif callback == "admin_pending_payments":
        await admin_pending_payments(update, context)

    elif callback.startswith("app_pay_") or callback.startswith("rej_pay_"):
        await admin_handle_payment(update, context)

    elif callback == "admin_set_coin_price":
        await admin_set_coin_price(update, context)

    elif callback == "admin_set_min_coins":
        await admin_set_min_coins(update, context)

    elif callback == "admin_set_cost_text":
        await admin_set_cost(update, context, "coin_cost_text", "💬 هزینه متن")
    elif callback == "admin_set_cost_photo":
        await admin_set_cost(update, context, "coin_cost_photo", "🖼️ هزینه عکس")
    elif callback == "admin_set_cost_video":
        await admin_set_cost(update, context, "coin_cost_video", "📹 هزینه ویدئو")
    elif callback == "admin_set_cost_document":
        await admin_set_cost(update, context, "coin_cost_document", "📎 هزینه فایل")
    elif callback == "admin_set_cost_link":
        await admin_set_cost(update, context, "coin_cost_link", "🔗 هزینه لینک")

    elif callback == "admin_set_legal_cost":
        await admin_set_general_setting(update, context, "legal_consult_coin_cost", "⚖️ هزینه مشاوره حقوقی")
    elif callback == "admin_set_lawyer_fee":
        await admin_set_general_setting(update, context, "lawyer_monthly_fee", "🧑‍⚖️ هزینه اشتراک ماهانه وکلا")

    elif callback == "admin_coin_packages":
        await admin_coin_packages(update, context)
    elif callback == "admin_add_package":
        await admin_add_package(update, context)
    elif callback == "admin_remove_package":
        await admin_remove_package(update, context)
    elif callback == "admin_toggle_package":
        await admin_toggle_package(update, context)

    elif callback == "admin_payment_methods":
        await admin_payment_methods(update, context)
    elif callback == "admin_set_receiver":
        await admin_set_receiver(update, context)

    elif callback == "admin_subscription_plans":
        await admin_subscription_plans(update, context)
    elif callback == "admin_manual_subscription":
        await admin_manual_subscription(update, context)
    elif callback == "admin_subscriptions_list":
        await admin_subscriptions_list(update, context)

    elif callback == "admin_dashboard":
        await admin_stats(update, context)

    elif callback == "admin_marketplaces":
        await admin_marketplaces(update, context)

    elif callback == "admin_lawyers_list":
        await admin_lawyers_list(update, context)
    elif callback == "admin_add_lawyer":
        await admin_add_lawyer(update, context)

    elif callback == "admin_track_payments":
        await admin_track_payments(update, context)

    elif callback == "admin_users_menu":
        await query.edit_message_text(get_text(lang, "user_management_menu"), reply_markup=InlineKeyboardMarkup(get_admin_users_menu(lang)))

    elif callback == "admin_find_user":
        context.user_data["awaiting_find_user"] = True
        await query.edit_message_text("🔍 لطفاً شناسه یا نام کاربر را وارد کنید:", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

    elif callback == "admin_private_msg":
        context.user_data["awaiting_private_msg"] = True
        await query.edit_message_text(get_text(lang, "private_message_prompt"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

    elif callback == "admin_broadcast":
        context.user_data["awaiting_broadcast"] = True
        await query.edit_message_text(get_text(lang, "broadcast_prompt"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

    elif callback == "admin_role_menu":
        context.user_data["awaiting_role_change"] = True
        await query.edit_message_text(get_text(lang, "promote_demote_menu"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

    elif callback == "admin_appearance_menu":
        keyboard = [
            [InlineKeyboardButton("📁 تنظیم کانال بایگانی", callback_data="admin_set_archive")],
            [InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")]
        ]
        await query.edit_message_text("🖌️ **مدیریت ظاهر و تنظیمات**", reply_markup=InlineKeyboardMarkup(keyboard))

    elif callback == "admin_set_archive":
        context.user_data["awaiting_archive_channel"] = True
        current = data["settings"].get("archive_channel_id", "تنظیم نشده")
        await query.edit_message_text(f"📁 **تنظیم کانال بایگانی**\nشناسه فعلی: {current}\nلطفاً شناسه عددی کانال را وارد کنید (مثال: -1001234567890):", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

    elif callback == "language":
        await language_menu(update, context)
    elif callback.startswith("setlang_"):
        await set_language(update, context)

    else:
        await query.edit_message_text("⏳ در حال توسعه...", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

# ==================== توابع خرید و پرداخت ====================
async def buy_coins(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    if not data["settings"]["features"].get("buy_coins_enabled", True):
        await query.edit_message_text("❌ خرید سکه در حال حاضر غیرفعال است.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    packages = data["settings"].get("coin_packages", [])
    price_per_coin = data["settings"].get("coin_price_toman", 30000)
    price_foreign = data["settings"].get("coin_price_foreign", 0.85)
    foreign_symbol = data["settings"].get("foreign_currency_symbol", "USDT")
    text = get_text(lang, "choose_package", price_per_coin=price_per_coin, price_foreign=price_foreign, foreign_currency_symbol=foreign_symbol)
    keyboard = []
    row = []
    for pkg in packages:
        if pkg.get("active", True):
            coins = pkg.get("coins", 0)
            row.append(InlineKeyboardButton(get_text(lang, "package_btn", coins=coins), callback_data=f"coin_pkg_{pkg['id']}"))
            if len(row) == 2:
                keyboard.append(row)
                row = []
    if row:
        keyboard.append(row)
    keyboard.append([InlineKeyboardButton(get_text(lang, "custom_coin"), callback_data="custom_coin")])
    keyboard.append(get_back_button(lang)[0])
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")

async def coin_package_selected(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    try:
        _, pkg_id = query.data.split("_", 2)[1:]
    except:
        await query.edit_message_text(get_text(lang, "processing_error"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    packages = data["settings"].get("coin_packages", [])
    pkg = next((p for p in packages if p["id"] == pkg_id), None)
    if not pkg or not pkg.get("active", True):
        await query.edit_message_text("❌ بسته نامعتبر.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    coins = pkg.get("coins", 0)
    price = pkg.get("price_toman", 0)
    price_foreign = data["settings"].get("coin_price_foreign", 0.85) * coins
    foreign_symbol = data["settings"].get("foreign_currency_symbol", "USDT")
    context.user_data["pending_purchase"] = {"coins": coins, "price": price, "pkg_id": pkg_id, "price_foreign": price_foreign}
    price_per_coin = data["settings"].get("coin_price_toman", 30000)
    price_per_coin_foreign = data["settings"].get("coin_price_foreign", 0.85)
    text = get_text(lang, "coin_purchase_summary", coins=coins, price_per_coin=price_per_coin, price_foreign=price_per_coin_foreign, foreign_currency_symbol=foreign_symbol, price=price, price_foreign_total=price_foreign)
    keyboard = [
        [InlineKeyboardButton(get_text(lang, "pay_card_btn"), callback_data="pay_card")],
        [InlineKeyboardButton(get_text(lang, "pay_trx_btn"), callback_data="pay_trx")],
        [InlineKeyboardButton(get_text(lang, "back"), callback_data="buy_coins")],
    ]
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")

async def custom_coin_request(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    context.user_data["awaiting_custom_coin"] = True
    await query.edit_message_text(get_text(lang, "custom_coin_prompt"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def confirm_custom_coin(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    amount = context.user_data.get("custom_coin_amount")
    total_price = context.user_data.get("custom_coin_price")
    price_foreign = context.user_data.get("custom_coin_foreign")
    if not amount:
        await query.edit_message_text(get_text(lang, "processing_error"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    context.user_data["pending_purchase"] = {"coins": amount, "price": total_price, "pkg_id": "custom", "price_foreign": price_foreign}
    price_per_coin = data["settings"].get("coin_price_toman", 30000)
    foreign_symbol = data["settings"].get("foreign_currency_symbol", "USDT")
    price_per_coin_foreign = data["settings"].get("coin_price_foreign", 0.85)
    text = get_text(lang, "coin_purchase_summary", coins=amount, price_per_coin=price_per_coin, price_foreign=price_per_coin_foreign, foreign_currency_symbol=foreign_symbol, price=total_price, price_foreign_total=price_foreign)
    keyboard = [
        [InlineKeyboardButton(get_text(lang, "pay_card_btn"), callback_data="pay_card")],
        [InlineKeyboardButton(get_text(lang, "pay_trx_btn"), callback_data="pay_trx")],
        [InlineKeyboardButton(get_text(lang, "back"), callback_data="buy_coins")],
    ]
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")

async def pay_card(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    pending = context.user_data.get("pending_purchase")
    if not pending:
        await query.edit_message_text(get_text(lang, "processing_error"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    coins = pending.get("coins", 0)
    price = pending.get("price", 0)
    payment_methods = data["settings"]["payment_methods"]
    rial_method = payment_methods.get("rial", {})
    cards = rial_method.get("cards", [])
    owner = rial_method.get("owner", "account_owner")
    owner_name = get_text(lang, owner, default=owner)
    cards_text = ""
    for idx, card in enumerate(cards, 1):
        bank_key = card.get("bank", "bank_unknown")
        bank_name = get_text(lang, bank_key, default=bank_key)
        cards_text += f"**{get_text(lang, 'card_number_prefix')} {idx}:**\n`{card.get('number', '')}`\n🏦 {bank_name}\n\n"
    text = get_text(lang, "payment_card_detail", coins=coins, price=price, cards_text=cards_text, owner=owner_name)
    keyboard = [[InlineKeyboardButton(get_text(lang, "back"), callback_data="buy_coins")]]
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
    context.user_data["awaiting_receipt"] = True
    # درخواست شماره پیگیری
    context.user_data["awaiting_tracking"] = True
    await query.message.reply_text("📝 لطفاً شماره پیگیری یا کد رهگیری واریز را وارد کنید:")

async def pay_trx(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    pending = context.user_data.get("pending_purchase")
    if not pending:
        await query.edit_message_text(get_text(lang, "processing_error"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    coins = pending.get("coins", 0)
    price = pending.get("price", 0)
    trx_method = data["settings"]["payment_methods"].get("trx", {})
    wallet = trx_method.get("wallet", "TW5PeEfiPXEaYf6ibFrxFrxLSDSX7AVZX1")
    network = trx_method.get("network", "TRC20")
    text = get_text(lang, "payment_trx_detail", coins=coins, price=price, wallet=wallet, network=network)
    keyboard = [[InlineKeyboardButton(get_text(lang, "back"), callback_data="buy_coins")]]
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
    context.user_data["awaiting_receipt"] = True
    context.user_data["awaiting_tracking"] = True
    await query.message.reply_text("📝 لطفاً شماره پیگیری یا کد رهگیری واریز را وارد کنید:")

async def handle_receipt(update, context):
    if not context.user_data.get("awaiting_receipt"):
        return
    user_id = str(update.effective_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    pending = context.user_data.get("pending_purchase")
    if not pending:
        await update.message.reply_text(get_text(lang, "processing_error"))
        return

    # اگر شماره پیگیری ثبت نشده، درخواست مجدد
    if not context.user_data.get("tracking_number"):
        await update.message.reply_text("📝 لطفاً شماره پیگیری را وارد کنید.")
        return

    tracking = context.user_data.get("tracking_number")
    coins = pending.get("coins", 0)
    price = pending.get("price", 0)
    payment_id = generate_id()

    if update.message.photo:
        file_id = update.message.photo[-1].file_id
    elif update.message.document:
        file_id = update.message.document.file_id
    else:
        await update.message.reply_text(get_text(lang, "receipt_required"))
        return

    data["pending_payments"][payment_id] = {
        "user_id": user_id,
        "coins": coins,
        "price": price,
        "file_id": file_id,
        "tracking": tracking,
        "status": "pending",
        "created_at": datetime.now().isoformat()
    }
    await save_data(data)

    # ارسال به کانال بایگانی
    archive_channel_id = data["settings"].get("archive_channel_id")
    if archive_channel_id and data["settings"]["features"].get("archive_payments_enabled", True):
        try:
            caption = (
                f"📨 **درخواست خرید سکه جدید**\n"
                f"🆔 شناسه: {payment_id}\n"
                f"👤 کاربر: {user_id}\n"
                f"🪙 تعداد: {coins} سکه\n"
                f"💰 مبلغ: {price:,} تومان\n"
                f"🔢 شماره پیگیری: {tracking}\n"
                f"📅 تاریخ: {format_datetime(datetime.now(), lang, 'full')}\n"
                f"⏳ وضعیت: در انتظار تأیید"
            )
            await context.bot.send_photo(chat_id=archive_channel_id, photo=file_id, caption=caption)
        except Exception as e:
            logger.error(f"خطا در ارسال به کانال بایگانی: {e}")

    # ارسال به ادمین
    try:
        receiver = int(data["settings"]["payment_receiver"]["chat_id"])
        await context.bot.send_photo(chat_id=receiver, photo=file_id,
                                     caption=f"📨 **درخواست خرید سکه**\n👤 {user_id}\n🪙 {coins}\n💰 {price:,} تومان\n🔢 پیگیری: {tracking}\n🆔 {payment_id}")
    except:
        pass

    context.user_data["awaiting_receipt"] = False
    context.user_data["pending_purchase"] = None
    context.user_data["tracking_number"] = None
    context.user_data["awaiting_tracking"] = False

    await update.message.reply_text(get_text(lang, "receipt_sent"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

# ==================== سایر توابع (خلاصه) ====================
async def invite(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    bot_username = (await context.bot.get_me()).username
    link = f"https://t.me/{bot_username}?start=ref_{user_id}"
    text = (
        "🎯 **انتخاب روش دعوت:**\n\n"
        "1️⃣ **دعوت با لینک:**\n"
        f"لینک اختصاصی شما:\n`{link}`\n"
        "با ارسال این لینک به دوستان، به ازای هر نفر ۵ سکه جایزه بگیرید.\n\n"
        "2️⃣ **دعوت از طریق گروه:**\n"
        "دوستان خود را به گروه تجارتخانه اضافه کنید و برای هر عضو جدید ۵ سکه دریافت کنید.\n"
        "🔗 لینک گروه: [لینک گروه](https://t.me/YourGroupLink)\n\n"
        "✅ هر دو روش قابل ترکیب هستند!"
    )
    keyboard = [
        [InlineKeyboardButton("📤 ارسال لینک", switch_inline_query=link)],
        [InlineKeyboardButton("👥 افزودن به گروه", url="https://t.me/YourGroupLink")],
        [InlineKeyboardButton("🔙 بازگشت", callback_data="menu")]
    ]
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")

async def free_coins(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    user = data["users"].get(user_id, {})
    last_claim = user.get("last_free_claim")
    now = datetime.now()
    if last_claim and (now - datetime.fromisoformat(last_claim)) < timedelta(hours=24):
        await query.edit_message_text(get_text(lang, "already_claimed"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    data["users"][user_id]["coins"] += 5
    data["users"][user_id]["last_free_claim"] = now.isoformat()
    await save_data(data)
    await query.edit_message_text(get_text(lang, "free_coins_claimed"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def guide(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    await query.edit_message_text(get_text(lang, "guide_text"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def my_coins(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    coins = data["users"].get(user_id, {}).get("coins", 0)
    await query.edit_message_text(get_text(lang, "my_coins_text", coins=coins), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def profile(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    user = data["users"].get(user_id, {})
    profile_data = user.get("profile", {})
    text = get_text(lang, "profile_text", first_name=user.get('first_name', 'کاربر'), coins=user.get('coins', 0))
    if profile_data:
        text += f"\n🏢 شرکت: {profile_data.get('company', 'ثبت نشده')}\n📱 تلفن: {profile_data.get('phone', 'ثبت نشده')}\n📍 محل فعالیت: {profile_data.get('location', 'ثبت نشده')}"
    keyboard = [
        [InlineKeyboardButton("✏️ ویرایش پروفایل", callback_data="edit_profile")],
        get_back_button(lang)[0]
    ]
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")

async def rules(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    await query.edit_message_text(get_text(lang, "rules_text"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)), parse_mode="Markdown")

async def public_groups(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    marketplaces = list(data.get("marketplaces", {}).values())
    page = context.user_data.get("market_page", 0)
    per_page = 7
    total_pages = (len(marketplaces) + per_page - 1) // per_page if marketplaces else 1
    if page >= total_pages:
        page = total_pages - 1
    start = page * per_page
    end = start + per_page
    page_markets = marketplaces[start:end]
    text = get_text(lang, "market_list_title", page=page+1, total=total_pages) + "\n\n"
    keyboard = []
    for m in page_markets:
        name = m.get(f"name_{lang}", m.get("name_fa", "بازار"))
        link = m.get("link", "#")
        keyboard.append([InlineKeyboardButton(f"{m.get('id', '')} {name}", url=link)])
    nav_btns = []
    if page > 0:
        nav_btns.append(InlineKeyboardButton("◀️ قبلی", callback_data="market_prev"))
    if page < total_pages - 1:
        nav_btns.append(InlineKeyboardButton("بعدی ▶️", callback_data="market_next"))
    if nav_btns:
        keyboard.append(nav_btns)
    keyboard.append(get_back_button(lang)[0])
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")

async def add_product(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    if not data["settings"]["features"].get("add_product_enabled", True):
        await query.edit_message_text("❌ ثبت آگهی در حال حاضر غیرفعال است.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    min_coins = data["settings"].get("min_coins_for_post", 5)
    user_coins = data["users"].get(user_id, {}).get("coins", 0)
    if user_coins < min_coins:
        await query.edit_message_text(get_text(lang, "not_enough_min_coins", min_coins=min_coins), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    context.user_data["awaiting_product"] = True
    await query.edit_message_text(get_text(lang, "product_form_desc"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)), parse_mode="Markdown")

async def handle_product_form(update, context):
    if not context.user_data.get("awaiting_product"):
        return
    user_id = str(update.effective_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    text = update.message.text.strip()
    lines = text.split("\n")
    if len(lines) < 6:
        await update.message.reply_text(get_text(lang, "product_form_fail"))
        return
    cost = data["settings"].get("coin_cost_text", 1)
    user_coins = data["users"].get(user_id, {}).get("coins", 0)
    if user_coins < cost:
        await update.message.reply_text(get_text(lang, "not_enough_coins"))
        return
    try:
        product_id = generate_id()
        data["products"][product_id] = {
            "user_id": user_id,
            "name": lines[0].strip(),
            "description": lines[1].strip(),
            "price": lines[2].strip(),
            "category": lines[3].strip(),
            "quantity": lines[4].strip(),
            "unit": lines[5].strip(),
            "created_at": datetime.now().isoformat(),
            "status": "active"
        }
        if "products" not in data["users"][user_id]:
            data["users"][user_id]["products"] = []
        data["users"][user_id]["products"].append(product_id)
        old_coins = data["users"][user_id]["coins"]
        data["users"][user_id]["coins"] -= cost
        new_coins = data["users"][user_id]["coins"]
        await save_data(data)
        context.user_data["awaiting_product"] = False
        report = get_text(lang, "ad_registration_report", name=lines[0].strip(), price=lines[2].strip(), cost=cost, old_coins=old_coins, new_coins=new_coins)
        await update.message.reply_text(report, reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
    except Exception as e:
        logger.error(f"خطا در ثبت آگهی: {e}")
        await update.message.reply_text(get_text(lang, "processing_error"))

# ==================== استعلام قیمت، مزایده، حقوقی، بازی‌ها (نمونه) ====================
async def price_inquiry(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    if not data["settings"]["features"].get("price_inquiry_enabled", True):
        await query.edit_message_text("❌ استعلام قیمت غیرفعال است.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    min_coins = data["settings"].get("min_coins_for_inquiry", 10)
    user_coins = data["users"].get(user_id, {}).get("coins", 0)
    if user_coins < min_coins:
        await query.edit_message_text(get_text(lang, "not_enough_min_coins", min_coins=min_coins), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    context.user_data["awaiting_inquiry"] = True
    await query.edit_message_text(get_text(lang, "inquiry_form_title"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def auctions(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    if not data["settings"]["features"].get("auctions_enabled", True):
        await query.edit_message_text("❌ مزایده‌ها غیرفعال هستند.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    await query.edit_message_text("⚡ **مزایده‌های فعال**\nبه زودی...", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def pin_product(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    if not data["settings"]["features"].get("pin_product_enabled", True):
        await query.edit_message_text("❌ پین آگهی غیرفعال است.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    await query.edit_message_text(get_text(lang, "pin_product_text"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def contests(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    if not data["settings"]["features"].get("contests_enabled", True):
        await query.edit_message_text("❌ مسابقات غیرفعال هستند.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    await query.edit_message_text(get_text(lang, "contests_text"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def calendar(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    await query.edit_message_text(get_text(lang, "calendar_text"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def legal_consult(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    if not data["settings"]["features"].get("legal_consult_enabled", True):
        await query.edit_message_text("❌ مشاوره حقوقی غیرفعال است.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    cost = data["settings"].get("legal_consult_coin_cost", 20)
    user_coins = data["users"].get(user_id, {}).get("coins", 0)
    if user_coins < cost:
        await query.edit_message_text(get_text(lang, "not_enough_min_coins", min_coins=cost), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    lawyers = [l for l in data.get("lawyers", {}).values() if l.get("is_active", False)]
    if not lawyers:
        await query.edit_message_text("⚠️ در حال حاضر وکیلی در دسترس نیست.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    lawyer = random.choice(lawyers)
    data["users"][user_id]["coins"] -= cost
    consult_id = generate_id()
    data["legal_consultations"][consult_id] = {
        "client_id": user_id,
        "lawyer_id": lawyer["user_id"],
        "assigned_at": datetime.now().isoformat(),
        "expires_at": (datetime.now() + timedelta(days=7)).isoformat(),
        "status": "active"
    }
    await save_data(data)
    text = get_text(lang, "legal_consult_assigned",
                    name=lawyer.get("full_name", "وکیل"),
                    phone=lawyer.get("phone", "نامشخص"),
                    telegram_id=lawyer.get("telegram_id", "نامشخص"),
                    bio=lawyer.get("bio", ""))
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def search(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    if not data["settings"]["features"].get("search_enabled", True):
        await query.edit_message_text("❌ جستجو غیرفعال است.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    context.user_data["awaiting_search"] = True
    await query.edit_message_text(get_text(lang, "search_prompt"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def register(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    if data["users"].get(user_id, {}).get("registered", False):
        await query.edit_message_text("✅ شما قبلاً ثبت‌نام کرده‌اید.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    context.user_data["awaiting_registration"] = True
    await query.edit_message_text("📝 **فرم ثبت‌نام**\nلطفاً اطلاعات زیر را وارد کنید:\n\nنام و نام خانوادگی:\nنام شرکت (اختیاری):\nشماره تماس (با کلیک روی دکمه ارسال شماره):", reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("📱 ارسال شماره تماس", request_contact=True)], get_back_button(lang)[0]]))

async def handle_registration(update, context):
    if not context.user_data.get("awaiting_registration"):
        return
    user_id = str(update.effective_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    if update.message.contact:
        phone = update.message.contact.phone_number
        if "profile" not in data["users"][user_id]:
            data["users"][user_id]["profile"] = {}
        data["users"][user_id]["profile"]["phone"] = phone
        data["users"][user_id]["registered"] = True
        await save_data(data)
        await update.message.reply_text("✅ ثبت‌نام شما با موفقیت انجام شد. ۵ سکه هدیه به حساب شما اضافه شد.")
        data["users"][user_id]["coins"] += 5
        await save_data(data)
        context.user_data["awaiting_registration"] = False
    else:
        lines = update.message.text.strip().split("\n")
        if len(lines) >= 1:
            if "profile" not in data["users"][user_id]:
                data["users"][user_id]["profile"] = {}
            data["users"][user_id]["profile"]["full_name"] = lines[0].strip()
            if len(lines) > 1:
                data["users"][user_id]["profile"]["company"] = lines[1].strip()
            await save_data(data)
            await update.message.reply_text("✅ اطلاعات ثبت شد. لطفاً شماره تماس خود را با کلیک روی دکمه ارسال شماره ارسال کنید.", reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("📱 ارسال شماره تماس", request_contact=True)]]))

# ==================== پنل مدیریت ====================
async def admin_panel(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        await query.edit_message_text(get_text("fa", "access_denied"), reply_markup=InlineKeyboardMarkup(get_back_button("fa")))
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    pending_count = len([p for p in data.get("pending_payments", {}).values() if p.get("status") == "pending"])
    text = get_text(lang, "admin_panel_text", pending_count=pending_count)
    keyboard = get_admin_main_menu(lang)
    if pending_count > 0:
        keyboard.insert(0, [InlineKeyboardButton(get_text(lang, "admin_pending_btn", count=pending_count), callback_data="admin_pending_payments")])
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")

async def admin_pending_payments(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    pending = {pid: p for pid, p in data.get("pending_payments", {}).items() if p.get("status") == "pending"}
    if not pending:
        await query.edit_message_text(get_text(lang, "no_pending_payments"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    list_text = ""
    keyboard = []
    for pid, p in pending.items():
        list_text += f"🆔 {pid}\n👤 {p['user_id']}\n🪙 {p['coins']} سکه\n💰 {p['price']:,} تومان\n🔢 پیگیری: {p.get('tracking', 'ندارد')}\n\n"
        keyboard.append([InlineKeyboardButton(get_text(lang, "confirm_btn", id=pid[:8]), callback_data=f"app_pay_{pid}")])
        keyboard.append([InlineKeyboardButton(get_text(lang, "reject_btn", id=pid[:8]), callback_data=f"rej_pay_{pid}")])
    keyboard.append(get_back_button(lang)[0])
    text = get_text(lang, "pending_payments_list", list_text=list_text)
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")

async def admin_handle_payment(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    try:
        action, payment_id = query.data.split("_", 2)[1:]
    except:
        await query.edit_message_text(get_text("fa", "processing_error"), reply_markup=InlineKeyboardMarkup(get_back_button("fa")))
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    if payment_id not in data["pending_payments"]:
        await query.edit_message_text("❌ درخواست یافت نشد.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    payment = data["pending_payments"][payment_id]
    target_user = payment["user_id"]
    if action == "app":
        coins = payment["coins"]
        data["users"][target_user]["coins"] = data["users"][target_user].get("coins", 0) + coins
        payment["status"] = "approved"
        await save_data(data)
        try:
            await context.bot.send_message(chat_id=int(target_user),
                                           text=f"✅ خرید شما تأیید شد! {coins} سکه اضافه شد.")
        except:
            pass
        await query.edit_message_text(get_text(lang, "payment_approved", payment_id=payment_id, coins=coins), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
    else:
        payment["status"] = "rejected"
        await save_data(data)
        try:
            await context.bot.send_message(chat_id=int(target_user),
                                           text="❌ درخواست خرید شما رد شد. لطفاً با پشتیبانی تماس بگیرید.")
        except:
            pass
        await query.edit_message_text(get_text(lang, "payment_rejected", payment_id=payment_id), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def admin_stats(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    active_users = len(data["users"])
    total_ads = len(data["products"])
    total_txs = len(data.get("transactions", {}))
    text = f"📊 **آمار کلی**\n\n👥 کاربران: {active_users}\n📦 آگهی‌ها: {total_ads}\n💳 تراکنش‌ها: {total_txs}\n🪙 سکه‌های در گردش: {sum(u.get('coins',0) for u in data['users'].values())}"
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(get_back_button(lang)), parse_mode="Markdown")

async def admin_features(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    features = data["settings"]["features"]
    features_list = ""
    keyboard = []
    for key, val in features.items():
        status = "✅" if val else "❌"
        features_list += f"{key}: {status}\n"
        keyboard.append([InlineKeyboardButton(f"{key} {status}", callback_data=f"toggle_feat_{key}")])
    keyboard.append(get_back_button(lang)[0])
    text = get_text(lang, "features_text", features_list=features_list)
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")

async def toggle_feature(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    _, feature_key = query.data.split("_", 2)[1:]
    data = await load_data()
    lang = get_user_lang(data, user_id)
    current = data["settings"]["features"].get(feature_key, True)
    data["settings"]["features"][feature_key] = not current
    await save_data(data)
    status = "فعال" if not current else "غیرفعال"
    await query.edit_message_text(get_text(lang, "feature_toggled", feature_key=feature_key, status=status), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def admin_set_coin_price(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    context.user_data["awaiting_coin_price"] = True
    current_price = data["settings"].get("coin_price_toman", 30000)
    current_foreign = data["settings"].get("coin_price_foreign", 0.85)
    foreign_symbol = data["settings"].get("foreign_currency_symbol", "USDT")
    text = get_text(lang, "set_coin_price_prompt", current_price=current_price, current_foreign=current_foreign, foreign_currency_symbol=foreign_symbol)
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(get_back_button(lang)), parse_mode="Markdown")

async def admin_set_min_coins(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    context.user_data["awaiting_setting"] = "min_coins_for_post"
    current = data["settings"].get("min_coins_for_post", 5)
    text = get_text(lang, "set_min_coins_prompt", current=current)
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def admin_set_cost(update, context, setting_key, label):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    context.user_data["awaiting_setting"] = setting_key
    current = data["settings"].get(setting_key, 1)
    text = get_text(lang, "set_cost_prompt", label=label, current=current)
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def admin_set_general_setting(update, context, setting_key, label):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    context.user_data["awaiting_setting"] = setting_key
    current = data["settings"].get(setting_key, 0)
    text = f"{label}\nمقدار فعلی: {current}\nلطفاً مقدار جدید را وارد کنید:"
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def admin_coin_packages(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    packages = data["settings"].get("coin_packages", [])
    packages_list = ""
    for p in packages:
        status = "✅ فعال" if p.get("active", True) else "❌ غیرفعال"
        packages_list += f"{status} - {p['coins']} سکه = {p['price_toman']:,} تومان (ID: {p['id']})\n"
    text = get_text(lang, "coin_packages_list", packages_list=packages_list)
    keyboard = [
        [InlineKeyboardButton("➕ افزودن بسته", callback_data="admin_add_package")],
        [InlineKeyboardButton("🗑️ حذف بسته", callback_data="admin_remove_package")],
        [InlineKeyboardButton("🔁 فعال/غیرفعال", callback_data="admin_toggle_package")],
        get_back_button(lang)[0]
    ]
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")

async def admin_add_package(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    context.user_data["awaiting_add_package"] = True
    await query.edit_message_text(get_text(lang, "add_package_prompt"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)), parse_mode="Markdown")

async def admin_remove_package(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    context.user_data["awaiting_remove_package"] = True
    await query.edit_message_text(get_text(lang, "remove_package_prompt"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def admin_toggle_package(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    context.user_data["awaiting_toggle_package"] = True
    await query.edit_message_text(get_text(lang, "toggle_package_prompt"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def admin_payment_methods(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    methods = data["settings"]["payment_methods"]
    methods_list = ""
    for key, val in methods.items():
        methods_list += f"{key}: {'✅' if val.get('enabled') else '❌'}\n"
    text = get_text(lang, "payment_methods_text", methods_list=methods_list)
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def admin_set_receiver(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    context.user_data["awaiting_receiver"] = True
    await query.edit_message_text(get_text(lang, "set_receiver_prompt"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def admin_subscription_plans(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    plans = data["settings"].get("subscription_plans", [])
    plans_list = ""
    for p in plans:
        plans_list += f"{p['name']}: {p['days']} روز - {p['price_toman']:,} تومان\n"
    text = get_text(lang, "subscription_plans_list", plans_list=plans_list)
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def admin_manual_subscription(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    context.user_data["awaiting_manual_sub"] = True
    await query.edit_message_text(get_text(lang, "manual_sub_prompt"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def admin_subscriptions_list(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    subs = data.get("subscriptions", {})
    lines = []
    for uid, sub in subs.items():
        lines.append(f"{uid}: {sub.get('plan_id','')} تا {sub.get('expiry','')[:10]}")
    text = get_text(lang, "subscriptions_list", subs_list="\n".join(lines) or "هیچ اشتراکی یافت نشد.")
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

async def admin_marketplaces(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    markets = data.get("marketplaces", {})
    text = "🏪 **مدیریت بازارها**\n\n"
    for mid, m in markets.items():
        text += f"{m.get('id')} - {m.get('name_fa', '')} : {m.get('link', '')}\n"
    keyboard = [
        [InlineKeyboardButton("➕ افزودن بازار", callback_data="admin_add_market")],
        [InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")]
    ]
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")

async def admin_lawyers_list(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    lawyers = data.get("lawyers", {})
    text = "📋 **لیست وکلا**\n\n"
    for lid, l in lawyers.items():
        status = "✅ فعال" if l.get("is_active", False) else "❌ غیرفعال"
        text += f"{l.get('full_name','')} - {l.get('specialty','')} - {status}\n"
    keyboard = [
        [InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")]
    ]
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")

async def admin_add_lawyer(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    context.user_data["awaiting_add_lawyer"] = True
    await query.edit_message_text(get_text(lang, "lawyer_reg_form"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

# ==================== توابع جدید مدیریت کاربران، برودکست، نقش ====================
async def admin_track_payments(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    payments = data.get("pending_payments", {})
    if not payments:
        await query.edit_message_text("📭 هیچ فیشی ثبت نشده است.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        return
    text = "📨 **لیست فیش‌های ثبت‌شده**\n\n"
    for pid, p in list(payments.items())[-10:]:
        status = "✅ تأیید" if p.get("status") == "approved" else "❌ رد" if p.get("status") == "rejected" else "⏳ در انتظار"
        text += f"🆔 {pid[:8]}... | {p.get('user_id')} | {p.get('coins')} سکه | {p.get('tracking', 'بدون پیگیری')} | {status}\n"
    keyboard = [[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")]]
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")

async def admin_find_user(update, context):
    # این تابع در text_handler پیاده‌سازی می‌شود
    pass

async def handle_find_user(update, context):
    user_id = str(update.effective_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    query_text = update.message.text.strip()
    # جستجو بر اساس شناسه یا نام
    found = None
    for uid, user in data["users"].items():
        if uid == query_text or user.get("first_name", "").lower() == query_text.lower():
            found = (uid, user)
            break
    if not found:
        await update.message.reply_text(get_text(lang, "user_not_found"))
        return
    uid, user = found
    sub_status = "❌ غیرفعال"
    if uid in data["subscriptions"]:
        expiry = data["subscriptions"][uid].get("expiry")
        if expiry and datetime.fromisoformat(expiry) > datetime.now():
            sub_status = "✅ فعال"
    text = get_text(lang, "user_profile_info",
                    user_id=uid,
                    name=user.get("first_name", "نامشخص"),
                    coins=user.get("coins", 0),
                    subscription=sub_status,
                    joined=user.get("joined", "نامشخص"),
                    ads=len(user.get("products", [])))
    keyboard = [
        [InlineKeyboardButton("💰 تغییر سکه", callback_data=f"edit_coins_{uid}")],
        [InlineKeyboardButton("📅 تغییر اشتراک", callback_data=f"edit_sub_{uid}")],
        [InlineKeyboardButton("💬 ارسال پیام", callback_data=f"msg_user_{uid}")],
        [InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")]
    ]
    await update.message.reply_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
    context.user_data["awaiting_find_user"] = False

async def admin_broadcast(update, context):
    # در text_handler پیاده‌سازی می‌شود
    pass

async def handle_broadcast(update, context):
    user_id = str(update.effective_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    msg = update.message.text.strip()
    if not msg:
        await update.message.reply_text("❌ پیام نباید خالی باشد.")
        return
    # ارسال به همه گروه‌ها (از لیست بازارها و اجاره‌ها)
    groups = []
    for m in data.get("marketplaces", {}).values():
        if m.get("link"):
            # تلاش برای ارسال به گروه (نیاز به شناسه عددی)
            pass
    for r in data.get("rentals", {}).values():
        if r.get("group_id"):
            groups.append(r["group_id"])
    sent_groups = 0
    for gid in groups:
        try:
            await context.bot.send_message(chat_id=gid, text=msg)
            sent_groups += 1
        except:
            pass
    # ارسال به همه کاربران (اختیاری)
    sent_users = 0
    for uid in data["users"].keys():
        try:
            await context.bot.send_message(chat_id=int(uid), text=msg)
            sent_users += 1
        except:
            pass
    await update.message.reply_text(get_text(lang, "broadcast_sent", groups=sent_groups, users=sent_users))
    context.user_data["awaiting_broadcast"] = False

async def admin_private_msg(update, context):
    # در text_handler پیاده‌سازی می‌شود
    pass

async def handle_private_msg(update, context):
    user_id = str(update.effective_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    text = update.message.text.strip()
    parts = text.split("-", 1)
    if len(parts) != 2:
        await update.message.reply_text(get_text(lang, "private_message_prompt"))
        return
    target_id = parts[0].strip()
    msg = parts[1].strip()
    try:
        await context.bot.send_message(chat_id=int(target_id), text=msg)
        await update.message.reply_text(get_text(lang, "private_message_sent", user_id=target_id))
    except:
        await update.message.reply_text(get_text(lang, "private_message_failed"))
    context.user_data["awaiting_private_msg"] = False

async def admin_role_change(update, context):
    # در text_handler پیاده‌سازی می‌شود
    pass

async def handle_role_change(update, context):
    user_id = str(update.effective_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    text = update.message.text.strip()
    parts = text.split("-")
    if len(parts) != 2:
        await update.message.reply_text(get_text(lang, "promote_demote_menu"))
        return
    target_user = parts[0].strip()
    group_id = parts[1].strip()
    # تلاش برای ارتقا به ادمین (در صورت امکان)
    try:
        await context.bot.promote_chat_member(chat_id=group_id, user_id=int(target_user),
                                              can_change_info=True, can_post_messages=True,
                                              can_edit_messages=True, can_delete_messages=True,
                                              can_invite_users=True, can_restrict_members=True,
                                              can_pin_messages=True, can_promote_members=False)
        await update.message.reply_text(get_text(lang, "promote_success", user_id=target_user, group_id=group_id))
    except Exception as e:
        # تلاش برای تنزل به کاربر عادی
        try:
            await context.bot.promote_chat_member(chat_id=group_id, user_id=int(target_user),
                                                  can_change_info=False, can_post_messages=False,
                                                  can_edit_messages=False, can_delete_messages=False,
                                                  can_invite_users=False, can_restrict_members=False,
                                                  can_pin_messages=False, can_promote_members=False)
            await update.message.reply_text(get_text(lang, "demote_success", user_id=target_user, group_id=group_id))
        except:
            await update.message.reply_text(get_text(lang, "role_change_error"))
    context.user_data["awaiting_role_change"] = False

async def handle_archive_channel_setting(update, context):
    user_id = str(update.effective_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    channel_id = update.message.text.strip()
    data["settings"]["archive_channel_id"] = channel_id
    await save_data(data)
    context.user_data["awaiting_archive_channel"] = False
    await update.message.reply_text("✅ کانال بایگانی با موفقیت تنظیم شد.", reply_markup=InlineKeyboardMarkup(get_back_button(lang)))

# ==================== زبان ====================
async def language_menu(update, context):
    query = update.callback_query
    user_id = str(query.from_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)
    keyboard = []
    for code, info in LANGUAGES.items():
        keyboard.append([InlineKeyboardButton(f"{info['emoji']} {info['name']}", callback_data=f"setlang_{code}")])
    keyboard.append(get_back_button(lang)[0])
    await query.edit_message_text(get_text(lang, "language_menu_title"), reply_markup=InlineKeyboardMarkup(keyboard))

async def set_language(update, context):
    query = update.callback_query
    _, lang_code = query.data.split("_", 1)
    user_id = str(query.from_user.id)
    data = await load_data()
    set_user_lang(data, user_id, lang_code)
    await save_data(data)
    lang_name = LANGUAGES.get(lang_code, {}).get("name", lang_code)
    coins = data["users"].get(user_id, {}).get("coins", 0)
    sub_status = "❌ غیرفعال"
    if user_id in data["subscriptions"]:
        expiry = data["subscriptions"][user_id].get("expiry")
        if expiry and datetime.fromisoformat(expiry) > datetime.now():
            sub_status = "✅ فعال"
    text = get_text(lang_code, "menu_title", coins=coins, subscription_status=sub_status)
    await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(get_main_menu(lang_code)), parse_mode="Markdown")

# ==================== Text Handler جامع ====================
async def text_handler(update, context):
    user_id = str(update.effective_user.id)
    data = await load_data()
    lang = get_user_lang(data, user_id)

    # دریافت شماره پیگیری
    if context.user_data.get("awaiting_tracking"):
        tracking = update.message.text.strip()
        if tracking:
            context.user_data["tracking_number"] = tracking
            context.user_data["awaiting_tracking"] = False
            await update.message.reply_text("✅ شماره پیگیری ثبت شد. لطفاً تصویر فیش را ارسال کنید.")
        else:
            await update.message.reply_text("❌ لطفاً شماره پیگیری معتبر وارد کنید.")
        return

    # دریافت کانال بایگانی
    if context.user_data.get("awaiting_archive_channel"):
        await handle_archive_channel_setting(update, context)
        return

    # جستجوی کاربر
    if context.user_data.get("awaiting_find_user"):
        await handle_find_user(update, context)
        return

    # ارسال پیام خصوصی
    if context.user_data.get("awaiting_private_msg"):
        await handle_private_msg(update, context)
        return

    # برودکست
    if context.user_data.get("awaiting_broadcast"):
        await handle_broadcast(update, context)
        return

    # تغییر نقش
    if context.user_data.get("awaiting_role_change"):
        await handle_role_change(update, context)
        return

    # ثبت‌نام
    if context.user_data.get("awaiting_registration"):
        await handle_registration(update, context)
        return

    # فرم آگهی
    if context.user_data.get("awaiting_product"):
        await handle_product_form(update, context)
        return

    # تنظیمات ادمین (عددی)
    if context.user_data.get("awaiting_setting"):
        await handle_setting_input(update, context)
        return

    # اشتراک دستی
    if context.user_data.get("awaiting_manual_sub"):
        text = update.message.text.strip()
        parts = text.split("-")
        if len(parts) == 2:
            target_user = parts[0].strip()
            plan_id = parts[1].strip()
            plans = data["settings"].get("subscription_plans", [])
            plan = next((p for p in plans if p["id"] == plan_id), None)
            if plan:
                expiry = datetime.now() + timedelta(days=plan["days"])
                data["subscriptions"][target_user] = {
                    "plan_id": plan_id,
                    "start": datetime.now().isoformat(),
                    "expiry": expiry.isoformat()
                }
                await save_data(data)
                await update.message.reply_text(get_text(lang, "manual_sub_success", target_user=target_user))
                context.user_data["awaiting_manual_sub"] = False
                return
        await update.message.reply_text(get_text(lang, "manual_sub_error"))
        return

    # دریافت‌کننده فیش
    if context.user_data.get("awaiting_receiver"):
        receiver = update.message.text.strip()
        data["settings"]["payment_receiver"]["chat_id"] = receiver
        await save_data(data)
        context.user_data["awaiting_receiver"] = False
        await update.message.reply_text(get_text(lang, "receiver_updated"))
        return

    # قیمت سکه
    if context.user_data.get("awaiting_coin_price"):
        await handle_coin_price_input(update, context)
        return

    # بسته‌های سکه
    if context.user_data.get("awaiting_add_package") or context.user_data.get("awaiting_remove_package") or context.user_data.get("awaiting_toggle_package"):
        await handle_admin_package_input(update, context)
        return

    # ثبت وکیل
    if context.user_data.get("awaiting_add_lawyer"):
        lines = update.message.text.strip().split("\n")
        if len(lines) >= 5:
            lawyer_data = {
                "user_id": str(update.effective_user.id),
                "full_name": lines[0].strip(),
                "bar_number": lines[1].strip(),
                "specialty": lines[2].strip(),
                "phone": lines[3].strip(),
                "telegram_id": lines[4].strip(),
                "bio": lines[5].strip() if len(lines) > 5 else "",
                "is_active": True,
                "subscription_expiry": (datetime.now() + timedelta(days=30)).isoformat(),
                "created_at": datetime.now().isoformat(),
                "total_consultations": 0
            }
            lawyer_id = generate_id()
            data["lawyers"][lawyer_id] = lawyer_data
            await save_data(data)
            await update.message.reply_text(get_text(lang, "lawyer_reg_success"))
            context.user_data["awaiting_add_lawyer"] = False
        else:
            await update.message.reply_text("❌ اطلاعات کامل نیست. لطفاً تمام فیلدها را پر کنید.")
        return

    # دریافت فیش
    if update.message.photo or update.message.document:
        await handle_receipt(update, context)
        return

    # پاسخ هوشمند ساده
    if data["settings"]["features"].get("smart_response_enabled", True):
        text = update.message.text
        if "؟" in text or "?" in text:
            await update.message.reply_text(get_text(lang, "smart_response", response="پاسخ شما به زودی توسط ادمین یا هوش مصنوعی ارسال خواهد شد."))

async def handle_setting_input(update, context):
    user_id = str(update.effective_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    setting_key = context.user_data.get("awaiting_setting")
    data = await load_data()
    lang = get_user_lang(data, user_id)
    try:
        value = int(update.message.text.strip())
        if value < 0:
            await update.message.reply_text(get_text(lang, "positive_number"))
            return
        data["settings"][setting_key] = value
        await save_data(data)
        context.user_data["awaiting_setting"] = None
        await update.message.reply_text(get_text(lang, "setting_updated"), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
    except ValueError:
        await update.message.reply_text(get_text(lang, "invalid_number"))

async def handle_coin_price_input(update, context):
    user_id = str(update.effective_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    try:
        new_price = int(update.message.text.strip())
        if new_price < 1000:
            await update.message.reply_text(get_text("fa", "coin_price_min_error"))
            return
        data = await load_data()
        data["settings"]["coin_price_toman"] = new_price
        await save_data(data)
        context.user_data["awaiting_coin_price"] = False
        await update.message.reply_text(get_text("fa", "coin_price_updated", new_price=new_price), reply_markup=InlineKeyboardMarkup(get_back_button("fa")))
    except ValueError:
        await update.message.reply_text(get_text("fa", "invalid_number"))

async def handle_admin_package_input(update, context):
    user_id = str(update.effective_user.id)
    if user_id != MASTER_ADMIN_ID:
        return
    data = await load_data()
    lang = get_user_lang(data, user_id)
    text = update.message.text.strip()
    if context.user_data.get("awaiting_add_package"):
        try:
            parts = text.split("-")
            if len(parts) != 2:
                await update.message.reply_text(get_text(lang, "invalid_format"))
                return
            coins = int(parts[0].strip())
            price = int(parts[1].strip())
            if coins <= 0 or price <= 0:
                await update.message.reply_text(get_text(lang, "positive_number"))
                return
            new_id = f"pkg{len(data['settings']['coin_packages'])+1}_{random.randint(100,999)}"
            data["settings"]["coin_packages"].append({
                "id": new_id,
                "coins": coins,
                "price_toman": price,
                "active": True
            })
            await save_data(data)
            context.user_data["awaiting_add_package"] = False
            await update.message.reply_text(get_text(lang, "package_added", coins=coins, price=price), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
        except ValueError:
            await update.message.reply_text(get_text(lang, "invalid_number"))
    elif context.user_data.get("awaiting_remove_package"):
        pkg_id = text.strip()
        packages = data["settings"]["coin_packages"]
        found = False
        for i, p in enumerate(packages):
            if p["id"] == pkg_id:
                removed = packages.pop(i)
                await save_data(data)
                context.user_data["awaiting_remove_package"] = False
                await update.message.reply_text(get_text(lang, "package_removed", coins=removed['coins']), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
                found = True
                break
        if not found:
            await update.message.reply_text(get_text(lang, "package_not_found"))
    elif context.user_data.get("awaiting_toggle_package"):
        pkg_id = text.strip()
        packages = data["settings"]["coin_packages"]
        found = False
        for p in packages:
            if p["id"] == pkg_id:
                p["active"] = not p.get("active", True)
                await save_data(data)
                context.user_data["awaiting_toggle_package"] = False
                status = "فعال" if p["active"] else "غیرفعال"
                await update.message.reply_text(get_text(lang, "package_toggled", coins=p['coins'], status=status), reply_markup=InlineKeyboardMarkup(get_back_button(lang)))
                found = True
                break
        if not found:
            await update.message.reply_text(get_text(lang, "package_not_found"))

# ==================== تسک‌های زمان‌بندی شده ====================
async def check_subscriptions(app):
    data = await load_data()
    now = datetime.now()
    for user_id, sub in list(data.get("subscriptions", {}).items()):
        expiry_str = sub.get("expiry")
        if expiry_str:
            expiry = datetime.fromisoformat(expiry_str)
            days_left = (expiry - now).days
            if days_left < 0:
                lang = get_user_lang(data, user_id)
                try:
                    await app.bot.send_message(chat_id=int(user_id),
                                               text=get_text(lang, "subscription_expired", plan_name=sub.get("plan_id", "")))
                except:
                    pass
                del data["subscriptions"][user_id]
                await save_data(data)
            elif days_left <= 7:
                lang = get_user_lang(data, user_id)
                try:
                    await app.bot.send_message(chat_id=int(user_id),
                                               text=f"⏰ اشتراک شما در {days_left} روز منقضی می‌شود. لطفاً تمدید کنید.")
                except:
                    pass

async def check_rentals(app):
    data = await load_data()
    now = datetime.now()
    for rental_id, rental in list(data.get("rentals", {}).items()):
        expiry_str = rental.get("subscription_expiry")
        if expiry_str:
            expiry = datetime.fromisoformat(expiry_str)
            if expiry < now:
                rental["is_active"] = False
                await save_data(data)
                try:
                    admin_id = rental.get("admin_user_id")
                    await app.bot.send_message(chat_id=int(admin_id),
                                               text=f"⏳ اشتراک گروه {rental.get('group_name')} منقضی شد. لطفاً تمدید کنید.")
                except:
                    pass

# ==================== اجرای اصلی ====================
def main():
    logger.info("🚀 ربات در حال راه‌اندازی...")
    request_kwargs = {"connect_timeout": 60.0, "read_timeout": 300.0, "write_timeout": 300.0}
    if PROXY_URL:
        request_kwargs["proxy_url"] = PROXY_URL
    request = HTTPXRequest(**request_kwargs)
    app = Application.builder().token(TOKEN).request(request).build()

    app.add_handler(CommandHandler("start", start))
    app.add_handler(CommandHandler("admin", admin_panel))
    app.add_handler(CallbackQueryHandler(button_handler))
    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, text_handler))
    app.add_handler(MessageHandler(filters.PHOTO | filters.Document.ALL, text_handler))
    app.add_handler(MessageHandler(filters.CONTACT, text_handler))

    scheduler = AsyncIOScheduler()
    scheduler.add_job(check_subscriptions, 'interval', hours=12, args=[app])
    scheduler.add_job(check_rentals, 'interval', hours=12, args=[app])
    scheduler.start()

    logger.info("✅ ربات آماده است، شروع Polling...")
    try:
        app.run_polling(poll_interval=0.5, timeout=120, drop_pending_updates=True)
    except Exception as e:
        logger.error(f"⚠️ خطا در Polling: {e}")

if __name__ == "__main__":
    while True:
        try:
            main()
        except KeyboardInterrupt:
            logger.info("🚦 ربات توسط کاربر متوقف شد.")
            break
        except Exception as e:
            logger.error(f"❌ خطای بحرانی: {e}")
            logger.info("🔄 تلاش برای راه‌اندازی مجدد در ۵ ثانیه...")
            time.sleep(5)