from rubka.asynco import Robot
from rubka.update import Message
from datetime import datetime, timedelta
import json
import time
import os
import asyncio
import jdatetime
from enum import Enum
from typing import Dict, Set, List, Optional, Any
import atexit
import logging
import re

# ================== تنظیمات لاگ ==================
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('bot.log', encoding='utf-8'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# ================== تنظیمات ==================
SUPER_ADMIN_GUID = "u0I5rgt03bb6ead51277d5e166802f20"
CREATOR_GUID = "u0EnBiA07752fb67d3fd31b791bcdea3"
CREATOR_GUID_2 = "u0Idvcm0751285136dc428d9185dac65"

ADMIN_ID_TEXT = "@Sale_Jaryane"
SUPPORT_ID_TEXT = "@Supports_Jaryane"
ADS_ID_TEXT = "@Ads_Jaryane"
SUPPORT_GROUP_LINK = "https://rubika.ir/joing/JCBCFIEJ0OWOANSKHZANDPHRQXQTAFGC"
ACTIVATION_TUTORIAL_LINK = "https://rubika.ir/JaryanStore/BFBBBEBCJJHGEHFH"
FILE_USERS_PATH = "data1/users.txt"
BOT_ID = "JCBCFIEJ0OWOANSKHZANDPHRQXQTAFGC"

TOKEN = "DBBBG0CKCNEDXJCJTYPZIHWZVCTZSQMTTXMIERQIMNWYROUBVRIPBFMTAOYNFZEY"

# ================== سطوح دسترسی ==================
class AdminLevel:
    SUPER_ADMIN = 3
    COIN_MANAGER = 4
    FULL_ADMIN = 2
    LIMITED_ADMIN = 1

class UserAction(str, Enum):
    CHOOSE_DELETE_TYPE = "choose_delete_type"
    AWAITING_FILE_BROADCAST = "awaiting_file_broadcast"
    AWAITING_BROADCAST_TEXT = "awaiting_broadcast_text"
    AWAITING_ALL_BROADCAST = "awaiting_all_broadcast"
    AWAITING_NAME_CHANGE = "awaiting_name_change"
    AWAITING_REFERRAL_CODE = "awaiting_referral_code"
    AWAITING_TEXT_EDIT = "awaiting_text_edit"
    AWAITING_AD_LINK = "awaiting_ad_link"
    AWAITING_AD_COUNT = "awaiting_ad_count"
    AWAITING_AD_CONFIRM = "awaiting_ad_confirm"

# ================== متن‌های ثابت ==================
PRICES_NEW_TEXT = """🌊 » لیست تعرفه سرور های دو‌گانه - تیم جریان 

🦋» با خرید هر پکیج، شما به ۲ تکنولوژی متفاوت جریان وب‌کاور و رِندِر‌موج مجهز می‌شوید. یک اشتراک، دو لایه قدرت!

​• یک کاربره 👤 » یک ماهه
📦 حجم: ۳۷ گیگابایت
💵 قیمت: ۱۱۹,۰۰۰ تومان
💎» ۲ لایه دسترسی (وب‌گردی + گیم)

​• یک کاربره 👤 » دو ماهه
📦 حجم: ۷۸ گیگابایت
💵 قیمت: ۱۸۵,۰۰۰ تومان
💎» ۲ لایه دسترسی (وب‌گردی + گیم)

​• یک کاربره 👤 » سه ماهه
📦 حجم: ۱۲۷ گیگابایت
💵 قیمت: ۲۹۹,۰۰۰ تومان
💎» ۲ لایه دسترسی (وب‌گردی + گیم)

​• یک کاربره 👤 » شش ماهه
📦 حجم: ۳۰۰ گیگابایت
💵 قیمت: ۵۴۹,۰۰۰ تومان
💎» ۲ لایه دسترسی (وب‌گردی + گیم)

​🛒 برای خرید، کلمه خرید را ارسال کنید."""

SUPPORT_NEW_TEXT = """📞» پشتیبانی و ارتباط

🦋» پشتیبانی جریان
• در صورت بروز هرگونه مشکل در اتصال یا اشتراک، پیام دهید تا فوراً رسیدگی شود. جریان؛ اینترنت پایدار، بدون دردسر.

🛠» پشتیبانی رسمی: @Supports_Jaryane

🔗» گروه پشتیبانی: https://rubika.ir/joing/JCBCFIEJ0OWOANSKHZANDPHRQXQTAFGC

💬 » چت آیدی شما: 

⚡» پاسخگویی سریع و دقیق"""

START_NEW_TEXT = """«قُلْ أَرَأَيْتُمْ إِنْ أَصْبَحَ مَاؤُكُمْ غَوْرًا فَمَنْ يَأْتِيكُمْ بِمَاءٍ مَعِينٍ»

به «جریان» خوش آمدید | 𝗪𝗲𝗹𝗰𝗼𝗺𝗲 𝘁𝗼 𝗝𝗮𝗿𝘆𝗮𝗻𝗲
ربات رسمی فروش تیم جریان | 𝗝𝗮𝗿𝘆𝗮𝗻𝗲 🛒🤍

📌» از طریق دکمه‌های زیر می‌تونی خیلی راحت خرید کنی، قیمت‌ها رو ببینی و پشتیبانی بگیری.

​✨️» خدمات ما در یک نگاه؛
• بهره‌مندی از پهنای باند اختصاصی
• پایداری در تمامی اپراتورها
• پشتیبانی هوشمند و متمرکز
• ثبت آگهی شما در ربات فروش جریان

​🎮» ویژه گیمرها؛
• پس از خرید و فعال‌سازی جریان وب‌ کاور به پشتیبانی پیام 💬 دهید. تا رِندِر‌موج را رایگان فعال کنند.

​🌊 » مجموعه جریان | 𝗝𝗮𝗿𝘆𝗮𝗻𝗲
• وب سایت 🌐 » is.gd/g8esYA‍
• کانال اطلاع‌رسانی رسمی 📡 » @JaryanStore
‍• کانال اعتماد مشتریان🦋» @Etemad_Jaryane"""

WHY_JARYANE_TEXT = """🌊 » چرا «جریان» انتخاب اول حرفه‌ای‌هاست؟
​در کنار پکیج دوگانه، اشتراک‌های جریان مجهز به ویژگی‌های زیر هستند:

​🛡» سیستم ضد-اختلال (Anti-Filter): استفاده از پل‌های اختصاصی برای عبور از فیلترینگ هوشمند و ملی شدن اینترنت.

​🔋» تکنولوژی کم‌مصرف: سرورهای ما طوری بهینه‌سازی شده‌اند که مصرف باتری گوشی شما را به حداقل می‌رسانند.

​🎮» پینگِ ثابت (Zero Lag): ویژ گیمر ها، سرویس رِندِر‌موج | 𝐑𝐞𝐧𝐝𝐞𝐫𝐌𝐮𝐠 با اولویت‌بندی، پینگ شما را در بازی‌های رقابتی پایدار نگه می‌دارد.

​👤» حریم خصوصی مطلق: هیچ داده‌ای از فعالیت‌های شما در سرورهای ما ذخیره نمی‌شود. امنیت شما، اعتبار ماست.

​🔄» سوئیچ خودکار IP: در صورت محدود شدن دسترسی به یک IP، IP جایگزین بلافاصله برای برقراری اتصال آماده خواهد بود.

​📡» پهنای باند اختصاصی: برخلاف اشتراک‌های ارزان‌قیمت بازار، پهنای باند در «جریان» بین کاربران تقسیم نمی‌شود و هر کاربر پورت اختصاصی خود را دارد."""

CANCEL_SERVICE_TEXT = """✅ اگر بعد از خرید سرویس جریان، از کیفیت خدمات رضایت نداشتید و یا در استفاده به مشکل خوردید لطفا با استفاده از دکمه پشتیبانی در منوی پایین، به تیم پشتیبانی ما پیام بفرستید و مشکلتون رو پیگیری کنید. درصورتی که مشکل برطرف نشد و همچنان از خدمات رضایت نداشتید در صورتی که کمتر از 1 هفته از خرید شما گذشته باشد میتوانید از پشتیبانی درخواست کنید که سرویس خریداری شده شما رو غیرفعال کنه و هزینه پرداختی شما رو پس بده"""

AD_REGISTER_TEXT = f"""📢 **بخش ثبت تبلیغات**

برای ثبت تبلیغ با پشتیبانی در ارتباط باشید:
🆔 {ADS_ID_TEXT}"""

# ================== متن‌های پیش‌فرض قابل ویرایش ==================
DEFAULT_TEXTS = {
    "start": START_NEW_TEXT,
    "prices": PRICES_NEW_TEXT,
    "support": SUPPORT_NEW_TEXT.replace("💬 » چت آیدی شما: ", "💬 » چت آیدی شما: {chat_id}"),
    "tutorial": f"""🎬» آموزش کامل خرید و فعال‌سازی

📌» مراحل خرید

1. از بخش «قیمت‌ها» پکیج را انتخاب کنید
2. مبلغ را واریز کنید
3. رسید پرداخت + Chat ID را برای ادمین بفرستید
4. منتظر تأیید پرداخت باشید
5. فایل‌های سرویس را دریافت کنید

🎯» آموزش فعال‌سازی سرور

• لینک آموزش ویدئویی: {{activation_link}}""",
    "ad_tutorial": """📚 **آموزش ثبت تبلیغات**

📌 **مراحل ثبت تبلیغ:**

1️⃣ از منوی تبلیغات، گزینه "📢 ثبت تبلیغ جدید" را بزنید
2️⃣ آیدی کانال خود را با @ وارد کنید (مثال: @MY_MILADM)
3️⃣ تعداد کاربران مورد نظر را انتخاب کنید (۱۰ تا ۱۰,۰۰۰ نفر)
4️⃣ سفارش را تأیید و سکه پرداخت کنید

✅ پس از تأیید، تبلیغ شما در صف انتظار قرار می‌گیرد
⏰ پس از فعال‌سازی، طبق تنظیمات نمایش داده می‌شود

💰 **تعرفه:**
• هر کاربر: ۲ سکه
• حداقل سفارش: ۱۰ کاربر
• حداکثر سفارش: ۱۰,۰۰۰ کاربر

📌 برای مشاهده وضعیت تبلیغات خود از گزینه "📊 تبلیغات من" استفاده کنید.""",
    "free_test": "برای جلوگیری از شلوغ شدن سرورها فعلا تست رایگان غیر فعال است میتوانید اشتراک خریداری کنید",
    "cancel_service": CANCEL_SERVICE_TEXT,
    "why_jaryane": WHY_JARYANE_TEXT,
    "free_coins_guide": """🪙» دریافت سکه رایگان
• با دعوت دوستان سکه رایگان بگیر!
• هر دعوت موفق: 4 سکه

🔗» کد دعوت شما: {guid}

📌» این کد رو برای دوستات بفرست تا در بخش دریافت کد دعوت وارد کنند و سکه رایگان دریافت کنید.""",
    "buy_coins": """🛒 **خرید سکه**

💎 **قیمت سکه:**
• ۱۰۰۰ سکه: ۵۰,۰۰۰ تومان
• ۵۰۰۰ سکه: ۲۰۰,۰۰۰ تومان
• ۱۰۰۰۰ سکه: ۳۵۰,۰۰۰ تومان

💳 **شماره کارت:**
`6037991781188051`
👤 به نام: مجیدی

📌 بعد از پرداخت، رسید رو به پشتیبانی بفرست.""",
    "stats": "📊» **آمار ربات فروش جریان**\n\n• تعداد کل کاربران: {total_users}\n• کاربران امروز: {today_users}\n\n🏆» اعتماد شما، افتخار ماست",
    "ad_template": """📢 **تبلیغات ویژه | جریان**

🆔 **آیدی کانال:**
{username}

🔗 **لینک:**
{link}

━━━━━━━━━━━━━━━━━━━━
🦋 **این تبلیغ تا {duration} دقیقه دیگر حذف خواهد شد.**
💎 **برای ثبت تبلیغ خود به ربات مراجعه کنید.**""",
    "ad_pricing_text": """💰 **تعرفه تبلیغات**

📊 **قیمت‌ها:**
• هر کاربر: {price} سکه
• حداقل سفارش: {min_users} کاربر = {min_cost} سکه
• حداکثر سفارش: {max_users} کاربر

⏰ **مدت نمایش:** {duration} دقیقه

🔄 **نحوه نمایش:**
تبلیغات به صورت نوبتی نمایش داده می‌شوند.
هر تبلیغ {duration} دقیقه فعال می‌ماند سپس حذف شده و تبلیغ بعدی نمایش داده می‌شود.

📋 **برای ثبت تبلیغ از دکمه 'ثبت تبلیغ جدید' استفاده کنید.**""",
    "buy_guide": """🛒 » راهنمای خرید

💳 » شماره کارت: {card_number}
به نام: {card_name}

📌 » بعد از پرداخت:
1: رسید پرداخت را به ادمین ارسال کنید
2: مدت (چند ماهه) را مشخص کنید
3: برای دریافت سرور (چت آیدی) تون برای آدمین فعال سازی بفرستین

💬 » چت آیدی شما: `{chat_id}`

🦋» ادمین فعال سازی : @Sale_Jaryane""",
}

# ================== کیبوردها ==================
def create_main_keyboard() -> Dict:
    return {
        "rows": [
            {"buttons": [{"id": "buy", "type": "Simple", "button_text": "🛒 خرید"},
                        {"id": "prices", "type": "Simple", "button_text": "💰 قیمت‌ها"}]},
            {"buttons": [{"id": "support", "type": "Simple", "button_text": "📞 پشتیبانی"},
                        {"id": "tutorial", "type": "Simple", "button_text": "🎬 آموزش"}]},
            {"buttons": [{"id": "advertising", "type": "Simple", "button_text": "📢 ثبت تبلیغات"},
                        {"id": "free_test", "type": "Simple", "button_text": "✅ تست رایگان"}]},
            {"buttons": [{"id": "cancel_service", "type": "Simple", "button_text": "❌ درخواست لغو"}]},
            {"buttons": [{"id": "stats", "type": "Simple", "button_text": "📊 آمار ربات"},
                        {"id": "profile", "type": "Simple", "button_text": "👤 پروفایل"}]},
            {"buttons": [{"id": "why_jaryane", "type": "Simple", "button_text": "🌊 چرا جریان؟"}]}
        ],
        "resize_keyboard": True, "one_time_keyboard": False
    }

def create_advertising_keyboard() -> Dict:
    return {
        "rows": [
            {"buttons": [{"id": "ad_1", "type": "Simple", "button_text": "📢 ثبت تبلیغ"}]},
            {"buttons": [{"id": "ad_2", "type": "Simple", "button_text": "🪙 دریافت سکه رایگان"},
                        {"id": "ad_3", "type": "Simple", "button_text": "🛒 خرید سکه"}]},
            {"buttons": [{"id": "ad_4", "type": "Simple", "button_text": "📚 آموزشات"}]},
            {"buttons": [{"id": "back_to_main", "type": "Simple", "button_text": "🔙 بازگشت به منوی اصلی"}]}
        ],
        "resize_keyboard": True, "one_time_keyboard": False
    }

def create_ad_panel_keyboard() -> Dict:
    return {
        "rows": [
            {"buttons": [{"id": "register_ad", "type": "Simple", "button_text": "📢 ثبت تبلیغ جدید"}]},
            {"buttons": [{"id": "ad_queue_status", "type": "Simple", "button_text": "📋 وضعیت صف"},
                        {"id": "ad_pricing", "type": "Simple", "button_text": "💰 تعرفه تبلیغات"}]},
            {"buttons": [{"id": "my_ads", "type": "Simple", "button_text": "📊 تبلیغات من"}]},
            {"buttons": [{"id": "back_to_advertising", "type": "Simple", "button_text": "🔙 بازگشت"}]}
        ],
        "resize_keyboard": True, "one_time_keyboard": False
    }

def create_admin_ad_keyboard() -> Dict:
    return {
        "rows": [
            {"buttons": [{"id": "admin_ad_queue", "type": "Simple", "button_text": "📋 صف تبلیغات"},
                        {"id": "admin_ad_active", "type": "Simple", "button_text": "🔄 تبلیغ فعال"}]},
            {"buttons": [{"id": "admin_ad_force_next", "type": "Simple", "button_text": "⏭️ رد کردن تبلیغ فعلی"},
                        {"id": "admin_ad_settings", "type": "Simple", "button_text": "⚙️ تنظیمات تبلیغات"}]},
            {"buttons": [{"id": "back_to_main", "type": "Simple", "button_text": "🔙 بازگشت"}]}
        ],
        "resize_keyboard": True, "one_time_keyboard": False
    }

def create_free_coins_keyboard() -> Dict:
    return {
        "rows": [
            {"buttons": [{"id": "enter_referral_code", "type": "Simple", "button_text": "📝 ثبت کد دعوت"}]},
            {"buttons": [{"id": "back_to_advertising", "type": "Simple", "button_text": "🔙 بازگشت"}]}
        ],
        "resize_keyboard": True, "one_time_keyboard": False
    }

def create_profile_keyboard() -> Dict:
    return {
        "rows": [
            {"buttons": [{"id": "change_name", "type": "Simple", "button_text": "✏️ تغییر نام"}]},
            {"buttons": [{"id": "back_to_main", "type": "Simple", "button_text": "🔙 بازگشت به منوی اصلی"}]}
        ],
        "resize_keyboard": True, "one_time_keyboard": False
    }

# ================== متغیرهای سراسری ==================
class BotState:
    def __init__(self):
        self.admin_greeted: Set[str] = set()
        self.users_notified: Set[str] = set()
        self.pending_files: List[Dict] = []
        self.sales_log: List[Dict] = []
        self.user_messages: Dict[str, Dict] = {}
        self.all_users_dict: Dict[str, str] = {}
        self.bot_start_time = time.time()
        self.daily_stats = {
            "date": datetime.now().strftime("%Y-%m-%d"),
            "users": set(), "sales": 0, "files_sent": 0, "messages": 0
        }

state = BotState()
settings: Dict = {}

# مسیر فایل‌ها
PATHS = {
    "bot_data": "data1/bot_data.json",
    "settings": "data1/settings.json",
    "admins": "data1/admins.json",
    "user_coins": "data1/user_coins.json",
    "admin_coins": "data1/admin_coins.json",
    "referrals": "data1/referrals.json",
    "user_names": "data1/user_names.json",
    "user_join": "data1/user_join_date.json",
    "total_coins": "data1/total_coins_received.json",
    "broadcast_all": "data1/sent_broadcast_all.json",
    "broadcast_file": "data1/sent_broadcast_file.json",
    "broadcast_bot": "data1/sent_broadcast_bot.json",
    "texts": "data1/texts.json",
    "invalid_guids": "data1/invalid_guids.txt",
    "invalid_chatids": "data1/invalid_chatids.txt",
    "ad_queue": "data1/ad_queue.json",
    "active_ad": "data1/active_ad.json",
    "ad_history": "data1/ad_history.json",
    "ad_settings": "data1/ad_settings.json",
    "total_users": "data1/total_users.json",
}

# مپینگ دکمه‌ها
BUTTON_TEXTS = {
    "🛒 خرید": "buy", "💰 قیمت‌ها": "prices", "📞 پشتیبانی": "support",
    "🎬 آموزش": "tutorial", "📢 ثبت تبلیغات": "advertising", "✅ تست رایگان": "free_test",
    "❌ درخواست لغو": "cancel_service", "📊 آمار ربات": "stats", "👤 پروفایل": "profile",
    "🌊 چرا جریان؟": "why_jaryane", "📢 ثبت تبلیغ": "ad_1", "🪙 دریافت سکه رایگان": "ad_2",
    "🛒 خرید سکه": "ad_3", "📚 آموزشات": "ad_4", "🔙 بازگشت به منوی اصلی": "back_to_main",
    "📝 ثبت کد دعوت": "enter_referral_code", "🔙 بازگشت": "back_to_advertising",
    "✏️ تغییر نام": "change_name",
    "📢 ثبت تبلیغ جدید": "register_ad", "📋 وضعیت صف": "ad_queue_status",
    "💰 تعرفه تبلیغات": "ad_pricing", "📊 تبلیغات من": "my_ads",
    "📋 صف تبلیغات": "admin_ad_queue", "🔄 تبلیغ فعال": "admin_ad_active",
    "⏭️ رد کردن تبلیغ فعلی": "admin_ad_force_next", "⚙️ تنظیمات تبلیغات": "admin_ad_settings"
}

# ================== توابع کمکی ==================
def safe_json_load(path: str, default: Any = None) -> Any:
    try:
        if os.path.exists(path):
            with open(path, "r", encoding="utf-8") as f:
                return json.load(f)
    except Exception as e:
        logger.error(f"Error loading {path}: {e}")
    return default if default is not None else {}

def safe_json_save(path: str, data: Any) -> bool:
    try:
        os.makedirs(os.path.dirname(path), exist_ok=True)
        with open(path, "w", encoding="utf-8") as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
        return True
    except Exception as e:
        logger.error(f"Error saving to {path}: {e}")
        return False

def safe_file_read(path: str) -> Set[str]:
    try:
        if os.path.exists(path):
            with open(path, "r", encoding="utf-8") as f:
                return {line.strip() for line in f if line.strip()}
    except Exception as e:
        logger.error(f"Error reading {path}: {e}")
    return set()

def safe_file_write(path: str, data: Set[str]) -> bool:
    try:
        os.makedirs(os.path.dirname(path), exist_ok=True)
        with open(path, "w", encoding="utf-8") as f:
            for item in data:
                f.write(f"{item}\n")
        return True
    except Exception as e:
        logger.error(f"Error writing to {path}: {e}")
        return False

def get_user_display(guid: str) -> str:
    return f"کاربر ({guid[:10]}...)"

async def send_with_keyboard(bot: Robot, chat_id: str, text: str, keyboard: Dict = None):
    try:
        return await bot.send_message(chat_id=chat_id, text=text, chat_keypad=keyboard or create_main_keyboard())
    except Exception as e:
        logger.error(f"Error sending message to {chat_id}: {e}")
        return None

# ================== مدیریت آمار ترکیبی ==================
def load_total_users() -> Dict:
    default = {"count": 0, "users": [], "last_update": None}
    return safe_json_load(PATHS["total_users"]) or default

def save_total_users(data: Dict):
    data["last_update"] = datetime.now().isoformat()
    safe_json_save(PATHS["total_users"], data)

def add_to_total_users(guid: str) -> bool:
    data = load_total_users()
    if guid not in data["users"]:
        data["users"].append(guid)
        data["count"] = len(data["users"])
        save_total_users(data)
        logger.info(f"📊 کاربر جدید: {guid[:15]}... | کل: {data['count']}")
        return True
    return False

def get_total_users_count() -> int:
    data = load_total_users()
    return data["count"]

def sync_total_users():
    data = load_total_users()
    bot_guids = set(state.all_users_dict.keys())
    file_guids = set(read_guids_from_file())
    all_guids = bot_guids | file_guids
    data["users"] = list(all_guids)
    data["count"] = len(all_guids)
    save_total_users(data)
    logger.info(f"🔄 آمار ترکیبی: {data['count']} کاربر")
    return data["count"]

# ================== مدیریت متن‌ها ==================
def load_texts() -> Dict:
    try:
        if os.path.exists(PATHS["texts"]):
            with open(PATHS["texts"], "r", encoding="utf-8") as f:
                return json.load(f)
    except:
        pass
    return DEFAULT_TEXTS.copy()

def save_texts(texts: Dict) -> bool:
    try:
        with open(PATHS["texts"], "w", encoding="utf-8") as f:
            json.dump(texts, f, ensure_ascii=False, indent=2)
        return True
    except:
        return False

def get_text(key: str, **kwargs) -> str:
    try:
        if os.path.exists(PATHS["texts"]):
            with open(PATHS["texts"], "r", encoding="utf-8") as f:
                texts = json.load(f)
            text = texts.get(key, DEFAULT_TEXTS.get(key, ""))
        else:
            text = DEFAULT_TEXTS.get(key, "")
    except:
        text = DEFAULT_TEXTS.get(key, "")
    if kwargs:
        try:
            return text.format(**kwargs)
        except:
            return text
    return text

def update_text(key: str, new_text: str) -> bool:
    if key not in DEFAULT_TEXTS:
        return False
    try:
        texts = load_texts()
        texts[key] = new_text
        with open(PATHS["texts"], "w", encoding="utf-8") as f:
            json.dump(texts, f, ensure_ascii=False, indent=2)
        return True
    except:
        return False

def list_texts() -> str:
    texts = load_texts()
    text = "📝 **متن‌های قابل ویرایش:**\n\n"
    for i, key in enumerate(DEFAULT_TEXTS.keys(), 1):
        preview = texts.get(key, "")[:50].replace("\n", " ")
        text += f"{i}. **{key}**\n   {preview}...\n\n"
    text += "\n📌 **دستورات:**\n• مشاهده متن <کلید>\n• ویرایش متن <کلید>\n• /variables - لیست متغیرها"
    return text

# ================== مدیریت ادمین‌ها ==================
def load_admins() -> Dict:
    default = {
        "super_admin": SUPER_ADMIN_GUID,
        "admins": {
            CREATOR_GUID: {"level": AdminLevel.FULL_ADMIN, "name": "سازنده اول", "added_by": SUPER_ADMIN_GUID, "added_at": datetime.now().isoformat()},
            CREATOR_GUID_2: {"level": AdminLevel.FULL_ADMIN, "name": "سازنده دوم", "added_by": SUPER_ADMIN_GUID, "added_at": datetime.now().isoformat()}
        }
    }
    return safe_json_load(PATHS["admins"]) or default

def save_admins(admins: Dict):
    safe_json_save(PATHS["admins"], admins)

def get_admin_level(guid: str) -> int:
    if guid == SUPER_ADMIN_GUID:
        return AdminLevel.SUPER_ADMIN
    admins = load_admins()
    return admins["admins"].get(guid, {}).get("level", 0)

def is_admin(guid: str) -> bool:
    return get_admin_level(guid) > 0

def can_access_stats(guid: str) -> bool:
    return get_admin_level(guid) >= AdminLevel.LIMITED_ADMIN

def can_manage_files(guid: str) -> bool:
    return get_admin_level(guid) >= AdminLevel.LIMITED_ADMIN

def can_broadcast(guid: str) -> bool:
    return get_admin_level(guid) >= AdminLevel.FULL_ADMIN

def can_manage_admins(guid: str) -> bool:
    return get_admin_level(guid) == AdminLevel.SUPER_ADMIN

def can_manage_coins(guid: str) -> bool:
    return get_admin_level(guid) in [AdminLevel.SUPER_ADMIN, AdminLevel.COIN_MANAGER]

def can_charge_admins(guid: str) -> bool:
    return get_admin_level(guid) == AdminLevel.SUPER_ADMIN

def can_deduct_coins(guid: str) -> bool:
    return get_admin_level(guid) in [AdminLevel.SUPER_ADMIN, AdminLevel.COIN_MANAGER]

def can_transfer_coins(guid: str) -> bool:
    return get_admin_level(guid) in [AdminLevel.SUPER_ADMIN, AdminLevel.FULL_ADMIN]

def can_manage_settings(guid: str) -> bool:
    return get_admin_level(guid) >= AdminLevel.FULL_ADMIN

def can_manage_ad_settings(guid: str) -> bool:
    return get_admin_level(guid) in [AdminLevel.SUPER_ADMIN, AdminLevel.COIN_MANAGER, AdminLevel.FULL_ADMIN]

def add_admin(new_guid: str, name: str, level: int, added_by: str) -> bool:
    if level == AdminLevel.SUPER_ADMIN:
        return False
    admins = load_admins()
    if new_guid not in admins["admins"] and new_guid != admins["super_admin"]:
        admins["admins"][new_guid] = {
            "level": level, "name": name, "added_by": added_by,
            "added_at": datetime.now().isoformat()
        }
        save_admins(admins)
        admin_coins = safe_json_load(PATHS["admin_coins"]) or {}
        admin_coins[new_guid] = 0
        safe_json_save(PATHS["admin_coins"], admin_coins)
        return True
    return False

def remove_admin(guid: str) -> bool:
    admins = load_admins()
    if guid in admins["admins"]:
        del admins["admins"][guid]
        save_admins(admins)
        return True
    return False

def change_admin_level(guid: str, new_level: int) -> bool:
    if new_level == AdminLevel.SUPER_ADMIN:
        return False
    admins = load_admins()
    if guid in admins["admins"]:
        admins["admins"][guid]["level"] = new_level
        save_admins(admins)
        return True
    return False

def list_all_admins() -> str:
    admins = load_admins()
    admin_coins = safe_json_load(PATHS["admin_coins"]) or {}
    level_names = {3: "👑 پرو", 4: "💰 مدیر سکه", 2: "⭐ کامل", 1: "📋 محدود"}
    text = f"👥 **لیست ادمین‌ها:**\n\n🌟 **سازنده پرو:**\n🆔 `{admins['super_admin'][:15]}...`\n💰 سکه: ∞\n\n"
    for guid, info in admins["admins"].items():
        text += f"{level_names.get(info['level'], '❓')} **{info['name']}**\n🆔 `{guid[:15]}...`\n💰 سکه: {admin_coins.get(guid, 0):,}\n\n"
    return text

# ================== مدیریت سکه ==================
def get_user_coins(guid: str) -> int:
    path = PATHS["admin_coins"] if is_admin(guid) else PATHS["user_coins"]
    return (safe_json_load(path) or {}).get(guid, 0)

def add_coins(guid: str, amount: int) -> int:
    is_admin_user = is_admin(guid)
    path = PATHS["admin_coins"] if is_admin_user else PATHS["user_coins"]
    coins = safe_json_load(path) or {}
    coins[guid] = coins.get(guid, 0) + amount
    safe_json_save(path, coins)
    if not is_admin_user:
        total = safe_json_load(PATHS["total_coins"]) or {}
        total[guid] = total.get(guid, 0) + amount
        safe_json_save(PATHS["total_coins"], total)
    return coins[guid]

def deduct_coins(guid: str, amount: int) -> bool:
    path = PATHS["admin_coins"] if is_admin(guid) else PATHS["user_coins"]
    coins = safe_json_load(path) or {}
    if coins.get(guid, 0) >= amount:
        coins[guid] -= amount
        safe_json_save(path, coins)
        return True
    return False

def get_total_coins_received(guid: str) -> int:
    return (safe_json_load(PATHS["total_coins"]) or {}).get(guid, 0)

# ================== مدیریت کاربران ==================
def get_user_name(guid: str) -> str:
    return (safe_json_load(PATHS["user_names"]) or {}).get(guid, "کاربر جریان")

def set_user_name(guid: str, name: str):
    names = safe_json_load(PATHS["user_names"]) or {}
    names[guid] = name[:50]
    safe_json_save(PATHS["user_names"], names)

def get_user_join_date(guid: str) -> Optional[str]:
    return (safe_json_load(PATHS["user_join"]) or {}).get(guid)

def set_user_join_date(guid: str):
    dates = safe_json_load(PATHS["user_join"]) or {}
    if guid not in dates:
        dates[guid] = datetime.now().isoformat()
        safe_json_save(PATHS["user_join"], dates)

def get_membership_duration(guid: str) -> str:
    join_str = get_user_join_date(guid)
    if not join_str:
        return "امروز"
    try:
        diff = datetime.now() - datetime.fromisoformat(join_str)
        months, days = divmod(diff.days, 30)
        return f"{months} ماه و {days} روز" if months else f"{days} روز"
    except:
        return "نامشخص"

def get_user_purchase_stats(guid: str) -> Dict:
    purchases = [s for s in state.sales_log if s.get("user") == guid]
    if not purchases:
        return {"count": 0, "last": None}
    last = max(purchases, key=lambda x: x.get("timestamp", ""))
    try:
        last_date = jdatetime.datetime.fromgregorian(
            datetime=datetime.fromisoformat(last["timestamp"])
        ).strftime('%Y/%m/%d')
    except:
        last_date = "نامشخص"
    return {"count": len(purchases), "last": last_date}

def get_user_level(guid: str) -> str:
    score = get_total_coins_received(guid) + get_user_purchase_stats(guid)['count'] * 1000 + get_referral_count(guid) * 500
    if score >= 100000: return "👑 الماسی"
    if score >= 50000: return "🌟 طلایی"
    if score >= 20000: return "⭐ نقره‌ای"
    if score >= 5000: return "📋 برنزی"
    return "🌱 تازه‌وارد"

# ================== مدیریت زیرمجموعه ==================
def load_referrals() -> Dict[str, List[str]]:
    return safe_json_load(PATHS["referrals"]) or {}

def save_referrals(refs: Dict[str, List[str]]):
    safe_json_save(PATHS["referrals"], refs)

def add_referral(inviter: str, new_user: str) -> bool:
    refs = load_referrals()
    if inviter not in refs:
        refs[inviter] = []
    if new_user not in refs[inviter] and new_user != inviter:
        refs[inviter].append(new_user)
        save_referrals(refs)
        return True
    return False

def get_referral_count(guid: str) -> int:
    return len(load_referrals().get(guid, []))

# ================== مدیریت فایل ==================
def read_guids_from_file() -> List[str]:
    try:
        if os.path.exists(FILE_USERS_PATH):
            with open(FILE_USERS_PATH, 'r', encoding='utf-8') as f:
                lines = [l.strip() for l in f if l.strip()]
                guids = [l for l in lines if len(l) >= 25 and l[0] in 'bu']
                logger.info(f"📁 خواندن {len(guids)} GUID از فایل")
                return guids
        else:
            logger.warning(f"❌ فایل {FILE_USERS_PATH} وجود ندارد!")
    except Exception as e:
        logger.error(f"Error reading users file: {e}")
    return []

def get_file_stats(guids: List[str]) -> Dict:
    total = len(guids)
    started = sum(1 for g in guids if g in state.all_users_dict and state.all_users_dict[g])
    return {"total": total, "started": started, "not_started": total - started,
            "percent": round(started / total * 100 if total else 0, 1)}

def get_invalid_guids() -> Set[str]:
    return safe_file_read(PATHS["invalid_guids"])

def save_invalid_guids(data: Set[str]):
    safe_file_write(PATHS["invalid_guids"], data)

def get_invalid_chatids() -> Set[str]:
    return safe_file_read(PATHS["invalid_chatids"])

def save_invalid_chatids(data: Set[str]):
    safe_file_write(PATHS["invalid_chatids"], data)

def remove_from_file(path: str, item: str) -> bool:
    items = safe_file_read(path)
    if item in items:
        items.remove(item)
        return safe_file_write(path, items)
    return False

# ================== ذخیره و بازیابی ==================
def save_all_data():
    data = {
        "all_users": state.all_users_dict,
        "users_notified": list(state.users_notified),
        "sales_log": state.sales_log,
        "admin_greeted": list(state.admin_greeted),
        "daily_stats": {
            "date": state.daily_stats["date"],
            "users": list(state.daily_stats["users"]),
            "sales": state.daily_stats["sales"],
            "files_sent": state.daily_stats["files_sent"],
            "messages": state.daily_stats["messages"]
        },
        "pending_files": state.pending_files,
        "bot_start_time": state.bot_start_time
    }
    safe_json_save(PATHS["bot_data"], data)

def load_all_data():
    data = safe_json_load(PATHS["bot_data"])
    if not data:
        return
    state.all_users_dict = data.get("all_users", {})
    state.users_notified = set(data.get("users_notified", []))
    state.sales_log = data.get("sales_log", [])
    state.admin_greeted = set(data.get("admin_greeted", []))
    daily = data.get("daily_stats", {})
    state.daily_stats = {
        "date": daily.get("date", datetime.now().strftime("%Y-%m-%d")),
        "users": set(daily.get("users", [])),
        "sales": daily.get("sales", 0),
        "files_sent": daily.get("files_sent", 0),
        "messages": daily.get("messages", 0)
    }
    state.pending_files = data.get("pending_files", [])
    state.bot_start_time = data.get("bot_start_time", time.time())

def log_sale(user_guid: str, amount: int, plan: str):
    state.sales_log.append({
        "user": user_guid, "amount": amount, "plan": plan,
        "timestamp": datetime.now().isoformat()
    })
    state.daily_stats["sales"] += 1
    save_all_data()

def reset_daily_stats_if_needed():
    today = datetime.now().strftime("%Y-%m-%d")
    if state.daily_stats.get("date") != today:
        state.daily_stats = {"date": today, "users": set(), "sales": 0, "files_sent": 0, "messages": 0}

# ================== تنظیمات ==================
def load_settings() -> Dict:
    return safe_json_load(PATHS["settings"]) or {
        "prices": {"برنزی": 119000, "نقره‌ای": 185000, "طلایی": 299000, "الماسی": 549000},
        "card_number": "6037991781188051", "card_name": "مجیدی"
    }

def save_settings(data: Dict):
    safe_json_save(PATHS["settings"], data)

# ================== تنظیمات تبلیغات ==================
def load_ad_settings() -> Dict:
    return safe_json_load(PATHS["ad_settings"]) or {
        "price_per_user": 2,
        "display_duration": 3600,
        "min_users_per_ad": 10,
        "max_users_per_ad": 10000,
    }

# ================== مدیریت صف تبلیغات ==================
class AdQueue:
    def __init__(self):
        self.queue: List[Dict] = safe_json_load(PATHS["ad_queue"]) or []
        self.active: Optional[Dict] = safe_json_load(PATHS["active_ad"]) or None
        self.settings = load_ad_settings()
    
    def save(self):
        safe_json_save(PATHS["ad_queue"], self.queue)
        safe_json_save(PATHS["active_ad"], self.active)
    
    def add_to_queue(self, ad_data: Dict) -> int:
        ad_data["id"] = f"ad_{int(time.time())}_{ad_data['user_guid'][:10]}"
        ad_data["status"] = "waiting"
        ad_data["created_at"] = datetime.now().isoformat()
        self.queue.append(ad_data)
        self.save()
        return len(self.queue)
    
    def get_queue_position(self, ad_id: str) -> int:
        for i, ad in enumerate(self.queue, 1):
            if ad.get("id") == ad_id:
                return i
        return -1
    
    def get_queue_info(self) -> str:
        if not self.queue:
            return "📭 **صف تبلیغات خالی است.**"
        text = f"📋 **صف تبلیغات**\n\n"
        text += f"🔄 تبلیغ فعال: {'✅ دارد' if self.active else '❌ ندارد'}\n"
        text += f"⏳ در انتظار: {len(self.queue)} تبلیغ\n\n"
        for i, ad in enumerate(self.queue[:10], 1):
            user = get_user_name(ad.get("user_guid", ""))
            username = ad.get("username", "")[:30]
            count = ad.get("target_count", 0)
            text += f"{i}. 👤 {user}\n   🆔 {username}\n   👥 {count} نفر\n\n"
        if len(self.queue) > 10:
            text += f"... و {len(self.queue) - 10} تبلیغ دیگر"
        return text
    
    async def process_queue(self, bot: Robot):
        while True:
            if self.active:
                elapsed = time.time() - self.active.get("start_time", time.time())
                if elapsed >= self.settings["display_duration"]:
                    await self.remove_active_ad(bot)
                else:
                    remaining = self.settings["display_duration"] - elapsed
                    await asyncio.sleep(min(60, remaining))
                    continue
            else:
                if self.queue:
                    await self.activate_next_ad(bot)
                else:
                    await asyncio.sleep(60)
    
    async def activate_next_ad(self, bot: Robot):
        if not self.queue:
            return
        
        ad = self.queue.pop(0)
        ad["status"] = "active"
        ad["sent_count"] = 0
        ad["failed_count"] = 0
        ad["message_ids"] = []
        
        settings = load_ad_settings()
        invalid_guids = get_invalid_guids()
        invalid_chatids = get_invalid_chatids()
        
        # ========== جمع‌آوری همه کاربران معتبر (مثل پیام همگانی) ==========
        all_targets = {}  # guid -> target (chat_id یا خود guid)
        
        # 1. کاربران ربات (Chat ID دارند)
        for guid, cid in state.all_users_dict.items():
            if cid and cid not in invalid_chatids and guid not in invalid_guids:
                all_targets[guid] = cid
        
        # 2. کاربران فایل (GUID هایی که در ربات نیستند)
        file_guids = read_guids_from_file()
        for guid in file_guids:
            if guid not in invalid_guids:
                if guid in state.all_users_dict and state.all_users_dict[guid]:
                    cid = state.all_users_dict[guid]
                    if cid not in invalid_chatids:
                        all_targets[guid] = cid
                else:
                    all_targets[guid] = guid
        
        all_valid_users = list(all_targets.items())
        target_count = min(ad["target_count"], len(all_valid_users))
        selected_users = all_valid_users[:target_count]
        
        bot_count = len([g for g, t in selected_users if g in state.all_users_dict and state.all_users_dict[g]])
        file_count = len([g for g, t in selected_users if g not in state.all_users_dict or not state.all_users_dict[g]])
        
        logger.info(f"🚀 فعال‌سازی تبلیغ برای {target_count} نفر")
        logger.info(f"   📊 کل معتبر: {len(all_valid_users)} (ربات: {len(state.all_users_dict)}, فایل: {len(file_guids)})")
        logger.info(f"   🎯 ارسال به: Chat ID: {bot_count}, GUID مستقیم: {file_count}")
        
        message_text = get_text("ad_template",
            username=ad.get("username", ""),
            link=ad.get("link", ""),
            duration=self.settings['display_duration'] // 60
        )
        
        for guid, target in selected_users:
            try:
                sent = await bot.send_message(chat_id=target, text=message_text)
                if sent and hasattr(sent, 'message_id'):
                    ad["sent_count"] += 1
                    ad["message_ids"].append({
                        "chat_id": target,
                        "message_id": sent.message_id
                    })
                else:
                    ad["failed_count"] += 1
                    if target.startswith('b') or target.startswith('u'):
                        invalid_guids.add(guid)
                        save_invalid_guids(invalid_guids)
                    else:
                        invalid_chatids.add(target)
                        save_invalid_chatids(invalid_chatids)
            except Exception as e:
                ad["failed_count"] += 1
                logger.error(f"خطا در ارسال تبلیغ به {guid[:15]}...: {e}")
                if target.startswith('b') or target.startswith('u'):
                    invalid_guids.add(guid)
                    save_invalid_guids(invalid_guids)
                else:
                    invalid_chatids.add(target)
                    save_invalid_chatids(invalid_chatids)
            await asyncio.sleep(0.3)
        
        ad["start_time"] = time.time()
        self.active = ad
        self.save()
        
        await self.notify_admins(bot, f"""
📢 **تبلیغ جدید فعال شد**

🆔 آیدی کانال: {ad.get('username', '')}
🔗 لینک: {ad.get('link', '')}
👤 ثبت‌کننده: {get_user_name(ad['user_guid'])}
👥 ارسال واقعی: {ad['sent_count']} / {ad['target_count']} نفر
❌ ناموفق: {ad['failed_count']}
⏰ مدت: {self.settings['display_duration'] // 60} دقیقه
""")
        
        if ad["user_guid"] in state.all_users_dict:
            try:
                await bot.send_message(
                    state.all_users_dict[ad["user_guid"]],
                    f"🎉 **تبلیغ شما فعال شد!**\n\n"
                    f"🆔 آیدی کانال: {ad.get('username', '')}\n"
                    f"✅ به {ad['sent_count']} نفر ارسال شد.\n"
                    f"⏰ به مدت {self.settings['display_duration'] // 60} دقیقه نمایش داده می‌شود.\n\n"
                    f"📌 پس از اتمام، پیام‌ها حذف خواهند شد."
                )
            except:
                pass
    async def remove_active_ad(self, bot: Robot):
        if not self.active:
            return
        
        logger.info(f"🗑️ حذف تبلیغ فعال - پاک کردن پیام‌ها")
        
        deleted = 0
        for msg in self.active.get("message_ids", []):
            try:
                await bot.delete_message(msg["chat_id"], msg["message_id"])
                deleted += 1
            except:
                pass
            await asyncio.sleep(0.2)
        
        history = safe_json_load(PATHS["ad_history"]) or []
        self.active["status"] = "completed"
        self.active["deleted_count"] = deleted
        self.active["end_time"] = time.time()
        history.append(self.active)
        safe_json_save(PATHS["ad_history"], history)
        
        await self.notify_admins(bot, f"""
📢 **تبلیغ به پایان رسید**

🆔 شناسه: {self.active['user_guid']}
🆔 آیدی کانال: {self.active.get('username', '')}
✅ ارسال واقعی: {self.active['sent_count']}
🗑️ پاک شده: {deleted}
⚠️ پاک نشده: {self.active['sent_count'] - deleted}
""")
        
        if self.active["user_guid"] in state.all_users_dict:
            try:
                await bot.send_message(
                    state.all_users_dict[self.active["user_guid"]],
                    f"📢 **تبلیغ شما به پایان رسید**\n\n"
                    f"🆔 آیدی کانال: {self.active.get('username', '')}\n"
                    f"✅ به {self.active['target_count']} نفر با موفقیت ارسال شد.\n"
                    f"🗑️ پیام‌ها از چت کاربران حذف شدند.\n\n"
                    f"📌 برای ثبت تبلیغ مجدد می‌توانید اقدام کنید."
                )
            except:
                pass
        
        self.active = None
        self.save()
        
        self.active = None
        self.save()
    
    async def notify_admins(self, bot: Robot, text: str):
        admins = load_admins()
        if admins["super_admin"] in state.all_users_dict:
            try:
                await bot.send_message(state.all_users_dict[admins["super_admin"]], text)
            except:
                pass
        for guid, info in admins["admins"].items():
            if info.get("level") == AdminLevel.COIN_MANAGER:
                if guid in state.all_users_dict:
                    try:
                        await bot.send_message(state.all_users_dict[guid], text)
                    except:
                        pass

ad_queue = AdQueue()

# ================== توابع ارسال همگانی ==================
async def broadcast_with_progress(bot: Robot, chat_id: str, targets: list, text: str, broadcast_type: str) -> Dict:
    total = len(targets)
    logger.info(f"🚀 شروع ارسال همگانی: نوع={broadcast_type}, تعداد={total}")
    
    try:
        progress_msg = await bot.send_message(
            chat_id, 
            f"⏳ **شروع ارسال همگانی**\n\n"
            f"🎯 کل: {total:,} نفر\n"
            f"📤 ارسال شده: 0\n"
            f"✅ موفق: 0\n"
            f"❌ ناموفق: 0"
        )
    except Exception as e:
        logger.error(f"❌ خطا در ایجاد پیام پیشرفت: {e}")
        progress_msg = None
    
    success = 0
    failed = 0
    sent_messages = []
    
    invalid_guids = get_invalid_guids()
    invalid_chatids = get_invalid_chatids()
    new_invalid_guids = set()
    new_invalid_chatids = set()
    
    path_map = {
        'bot': PATHS["broadcast_bot"],
        'file': PATHS["broadcast_file"],
        'all': PATHS["broadcast_all"]
    }
    
    save_path = path_map.get(broadcast_type)
    if not save_path:
        return {"success": 0, "failed": total, "sent_messages": []}
    
    existing_messages = safe_json_load(save_path) or []
    
    for i, target in enumerate(targets, 1):
        chat_target = target
        if target in state.all_users_dict and state.all_users_dict[target]:
            chat_target = state.all_users_dict[target]
        
        if not chat_target:
            failed += 1
            if target.startswith('b'):
                new_invalid_guids.add(target)
            else:
                new_invalid_chatids.add(target)
            continue
        
        if chat_target in invalid_chatids:
            failed += 1
            continue
        
        try:
            full_text = f"📢 **پیام مدیریت**\n\n{text}\n\n━━━━━━━━━━━━━━━\n📌 @JaryanStore"
            sent = await bot.send_message(chat_id=chat_target, text=full_text)
            
            if sent and hasattr(sent, 'message_id'):
                success += 1
                sent_messages.append({
                    "chat_id": chat_target,
                    "message_id": sent.message_id,
                    "timestamp": datetime.now().isoformat()
                })
            else:
                failed += 1
                new_invalid_chatids.add(chat_target)
                
        except Exception as e:
            failed += 1
            if "Chat not found" in str(e):
                new_invalid_chatids.add(chat_target)
            elif target.startswith('b'):
                new_invalid_guids.add(target)
        
        if i % 50 == 0 or i == total:
            if progress_msg:
                try:
                    percent = int(i/total*100) if total > 0 else 0
                    await progress_msg.edit_text(
                        f"⏳ **در حال ارسال همگانی**\n\n"
                        f"🎯 کل: {total:,} نفر\n"
                        f"📤 ارسال شده: {i:,} نفر ({percent}%)\n"
                        f"✅ موفق: {success:,} نفر\n"
                        f"❌ ناموفق: {failed:,} نفر\n"
                        f"━━━━━━━━━━━━━━━━\n"
                        f"📊 **گزارش ۵۰ تایی:**\n"
                        f"• GUID جدید ناموفق: {len(new_invalid_guids):,}\n"
                        f"• Chat ID جدید ناموفق: {len(new_invalid_chatids):,}"
                    )
                    logger.info(f"📊 گزارش ۵۰ تایی: {i}/{total} - موفق: {success}, ناموفق: {failed}")
                except:
                    pass
            await asyncio.sleep(0.5)
    
    if sent_messages:
        existing_messages.extend(sent_messages)
        safe_json_save(save_path, existing_messages)
    
    if new_invalid_guids:
        invalid_guids.update(new_invalid_guids)
        save_invalid_guids(invalid_guids)
    
    if new_invalid_chatids:
        invalid_chatids.update(new_invalid_chatids)
        save_invalid_chatids(invalid_chatids)
    
    final_report = f"""
✅ **ارسال همگانی به پایان رسید**

📊 **گزارش نهایی:**
━━━━━━━━━━━━━━━━━━━━
🎯 کل هدف: {total:,} نفر
✅ موفق: {success:,} ({(success/total*100) if total > 0 else 0:.1f}%)
❌ ناموفق: {failed:,} ({(failed/total*100) if total > 0 else 0:.1f}%)

🆕 **ناموفق‌های جدید:**
• GUID: {len(new_invalid_guids):,}
• Chat ID: {len(new_invalid_chatids):,}

💾 پیام‌های ذخیره شده: {len(sent_messages):,}
"""
    
    if progress_msg:
        try:
            await progress_msg.edit_text(final_report)
        except:
            await bot.send_message(chat_id, final_report)
    else:
        await bot.send_message(chat_id, final_report)
    
    logger.info(f"🏁 ارسال همگانی پایان یافت: موفق={success}, ناموفق={failed}")
    return {"success": success, "failed": failed, "sent_messages": sent_messages}

async def delete_broadcast_messages(bot: Robot, chat_id: str, broadcast_type: str) -> str:
    type_names = {'bot': "ارسال همگانی (ربات)", 'file': "ارسال به فایل", 'all': "ارسال به همه"}
    path_map = {'bot': PATHS["broadcast_bot"], 'file': PATHS["broadcast_file"], 'all': PATHS["broadcast_all"]}
    
    path = path_map.get(broadcast_type)
    type_name = type_names.get(broadcast_type, broadcast_type)
    
    if not path or not os.path.exists(path):
        return f"❌ هیچ پیامی از نوع '{type_name}' وجود ندارد."
    
    try:
        with open(path, "r", encoding="utf-8") as f:
            sent_messages = json.load(f)
    except:
        sent_messages = []
    
    if not sent_messages:
        return f"📭 هیچ پیامی از نوع '{type_name}' برای پاک کردن وجود ندارد."
    
    await bot.send_message(chat_id, f"⏳ شروع پاک کردن {len(sent_messages)} پیام...")
    
    success = 0
    for i, msg in enumerate(sent_messages[:100], 1):
        try:
            await bot.delete_message(msg["chat_id"], msg["message_id"])
            success += 1
        except:
            pass
        await asyncio.sleep(0.1)
    
    with open(path, "w", encoding="utf-8") as f:
        json.dump([], f)
    
    return f"✅ **پاکسازی انجام شد**\n\n📝 نوع: {type_name}\n✅ پاک شده: {success:,}"

# ================== نمایش پروفایل ==================
async def show_profile(bot: Robot, chat_id: str, guid: str):
    stats = get_user_purchase_stats(guid)
    join_str = get_user_join_date(guid)
    try:
        jalali_join = jdatetime.datetime.fromgregorian(
            datetime=datetime.fromisoformat(join_str)
        ).strftime('%Y/%m/%d') if join_str else "امروز"
    except:
        jalali_join = "نامشخص"
    
    text = f"""
🗄️» **پروفایل شما**

👤» نام: {get_user_name(guid)}
• سطح: {get_user_level(guid)}
• عضویت: {jalali_join}

💰» موجودی سکه های شما
• موجودی: {get_user_coins(guid):,} سکه
• زیرمجموعه: {get_referral_count(guid)} نفر

📦» سرور های دریافتی شما
• تعداد دریافت سرور: {stats['count']} فایل
• آخرین دریافت سرور: {stats['last'] or 'ندارد'}

🆔» شناسه شما:
`{guid}`

💬» چت آیدی شما:
`{chat_id}`

🔗» کد دعوت شما:
`{guid}`
"""
    await send_with_keyboard(bot, chat_id, text, create_profile_keyboard())

# ================== راه‌اندازی ==================
os.makedirs("data1", exist_ok=True)
settings = load_settings()
load_all_data()
sync_total_users()
logger.info(f"داده‌ها بارگذاری شدند - کاربران: {len(state.all_users_dict)}")

try:
    from rubka.methods import Auth
    auth = Auth(token=TOKEN)
    bot = Robot(auth=auth)
    logger.info(f"🛒 ربات با Auth اجرا شد")
except:
    try:
        bot = Robot(token=TOKEN)
        logger.info(f"🛒 ربات با Token اجرا شد")
    except:
        bot = Robot(TOKEN)
        logger.info(f"🛒 ربات با فرمت قدیمی اجرا شد")

logger.info(f"پرو: {SUPER_ADMIN_GUID[:15]}...")

# ================== هندلر اصلی ==================
@bot.on_message()
async def handler(bot: Robot, message: Message):
    if not message.is_private:
        return

    text = (message.text or "").strip()
    sender_guid = message.sender_id
    chat_id = message.chat_id
    
    IS_ADMIN = is_admin(sender_guid)
    IS_NORMAL = not IS_ADMIN
    
    reset_daily_stats_if_needed()
    state.daily_stats["messages"] += 1
    state.all_users_dict[sender_guid] = chat_id
    state.daily_stats["users"].add(sender_guid)
    
    if state.daily_stats["messages"] % 10 == 0:
        save_all_data()
    
    detected = None
    if hasattr(message, 'keypad_id') and message.keypad_id:
        detected = message.keypad_id
    elif text in BUTTON_TEXTS:
        detected = BUTTON_TEXTS[text]
    
    # ================== کاربران عادی ==================
    if detected and IS_NORMAL:
        if detected == "buy":
            sets = load_settings()
            buy_text = get_text("buy_guide", 
                card_number=sets['card_number'],
                card_name=sets['card_name'],
                chat_id=chat_id
            )
            await send_with_keyboard(bot, chat_id, buy_text)
        elif detected == "prices":
            await send_with_keyboard(bot, chat_id, get_text("prices"))
        elif detected == "support":
            await send_with_keyboard(bot, chat_id, get_text("support", chat_id=chat_id))
        elif detected == "tutorial":
            await send_with_keyboard(bot, chat_id, get_text("tutorial", activation_link=ACTIVATION_TUTORIAL_LINK))
        elif detected == "advertising":
            ad_settings = load_ad_settings()
            text_ad = f"""
📢 **بخش تبلیغات**

🔗 **قوانین ثبت تبلیغ:**
• فقط آیدی کانال روبیکا (با @)
• هزینه: {ad_settings['price_per_user']} سکه به ازای هر کاربر
• حداقل: {ad_settings.get('min_users_per_ad', 10):,} کاربر | حداکثر: {ad_settings['max_users_per_ad']:,} کاربر
• نمایش: {ad_settings['display_duration'] // 60} دقیقه

💰 **موجودی شما:** {get_user_coins(sender_guid):,} سکه

👇 یکی از گزینه‌های زیر را انتخاب کنید:
"""
            await send_with_keyboard(bot, chat_id, text_ad, create_advertising_keyboard())
        elif detected == "free_test":
            await send_with_keyboard(bot, chat_id, get_text("free_test"))
        elif detected == "cancel_service":
            await send_with_keyboard(bot, chat_id, get_text("cancel_service"))
        elif detected == "stats":
            total_users = get_total_users_count()
            today_users = len(state.daily_stats['users'])
            stats_text = get_text("stats", total_users=f"{total_users:,}", today_users=f"{today_users:,}")
            await send_with_keyboard(bot, chat_id, stats_text)
        elif detected == "profile":
            await show_profile(bot, chat_id, sender_guid)
        elif detected == "why_jaryane":
            await send_with_keyboard(bot, chat_id, get_text("why_jaryane"))
        elif detected == "ad_1":
            await send_with_keyboard(bot, chat_id, "📢 **پنل ثبت تبلیغات**\n\nلطفاً یکی از گزینه‌های زیر را انتخاب کنید:", create_ad_panel_keyboard())
        elif detected == "ad_2":
            await bot.send_message(chat_id, get_text("free_coins_guide", guid=sender_guid), chat_keypad=create_free_coins_keyboard())
        elif detected == "ad_3":
            await bot.send_message(chat_id, get_text("buy_coins"), chat_keypad=create_advertising_keyboard())
        elif detected == "ad_4":
            await bot.send_message(chat_id, get_text("ad_tutorial"), chat_keypad=create_advertising_keyboard())
        elif detected == "enter_referral_code":
            state.user_messages[sender_guid] = {"action": UserAction.AWAITING_REFERRAL_CODE.value}
            await bot.send_message(chat_id, "📝 **لطفاً کد دعوت دوست خود را وارد کنید:**\n\n(کد دعوت = GUID دعوت‌کننده)\n\n❌ برای لغو: /cancel")
        elif detected == "back_to_advertising":
            ad_settings = load_ad_settings()
            text_ad = f"""
📢 **بخش تبلیغات**

🔗 **قوانین ثبت تبلیغ:**
• فقط آیدی کانال روبیکا (با @)
• هزینه: {ad_settings['price_per_user']} سکه به ازای هر کاربر
• حداقل: {ad_settings.get('min_users_per_ad', 10):,} کاربر | حداکثر: {ad_settings['max_users_per_ad']:,} کاربر
• نمایش: {ad_settings['display_duration'] // 60} دقیقه

💰 **موجودی شما:** {get_user_coins(sender_guid):,} سکه

👇 یکی از گزینه‌های زیر را انتخاب کنید:
"""
            await send_with_keyboard(bot, chat_id, text_ad, create_advertising_keyboard())
        elif detected == "change_name":
            state.user_messages[sender_guid] = {"action": UserAction.AWAITING_NAME_CHANGE.value}
            await bot.send_message(chat_id, "✏️ **لطفاً نام جدید خود را وارد کنید:**\n\n(حداکثر ۵۰ کاراکتر)")
        elif detected == "back_to_main":
            await send_with_keyboard(bot, chat_id, "🏠 **بازگشت به منوی اصلی**")
        
        # ================== تبلیغات ==================
        elif detected == "register_ad":
            state.user_messages[sender_guid] = {"action": UserAction.AWAITING_AD_LINK.value}
            await bot.send_message(
                chat_id,
                "🔗 **لطفاً آیدی کانال خود را ارسال کنید:**\n\n"
                "📌 مثال: @MY_MILADM\n\n"
                "❌ برای لغو: /cancel"
            )
        elif detected == "ad_queue_status":
            await message.reply(ad_queue.get_queue_info())
        elif detected == "ad_pricing":
            ad_settings = load_ad_settings()
            text_ad = get_text("ad_pricing_text",
                price=ad_settings['price_per_user'],
                min_users=ad_settings.get('min_users_per_ad', 10),
                max_users=ad_settings['max_users_per_ad'],
                duration=ad_settings['display_duration'] // 60,
                min_cost=ad_settings.get('min_users_per_ad', 10) * ad_settings['price_per_user']
            )
            await message.reply(text_ad)
        elif detected == "my_ads":
            my_ads = [ad for ad in ad_queue.queue if ad.get("user_guid") == sender_guid]
            if ad_queue.active and ad_queue.active.get("user_guid") == sender_guid:
                my_ads.insert(0, ad_queue.active)
            
            if not my_ads:
                await message.reply("📭 شما هیچ تبلیغ فعال یا در انتظاری ندارید.")
            else:
                text_ad = "📊 **تبلیغات شما:**\n\n"
                for ad in my_ads[:5]:
                    status = "🔄 فعال" if ad.get("status") == "active" else "⏳ در انتظار"
                    position = ad_queue.get_queue_position(ad.get("id", "")) if ad.get("status") == "waiting" else 0
                    text_ad += f"🆔 {ad.get('username', '')}\n"
                    text_ad += f"👥 سفارش: {ad.get('target_count', 0)} نفر\n"
                    text_ad += f"📊 وضعیت: {status}"
                    if position > 0:
                        text_ad += f" (نوبت {position})"
                    text_ad += "\n\n"
                await message.reply(text_ad)
        return

    # ================== /start ==================
    if text == "/start":
        if IS_NORMAL:
            remove_from_file(PATHS["invalid_guids"], sender_guid)
            remove_from_file(PATHS["invalid_chatids"], chat_id)
            set_user_join_date(sender_guid)
            add_to_total_users(sender_guid)
            await send_with_keyboard(bot, chat_id, get_text("start"))
        else:
            level = get_admin_level(sender_guid)
            await message.reply(
                f"سلام ادمین عزیز 👑\n\n"
                f"🆔 GUID شما: {sender_guid}\n"
                f"🔹 سطح دسترسی: {level}\n"
                f"🔹 Chat ID شما: {chat_id}\n\n"
                "📋 /panel - پنل مدیریت\n"
                "🔍 /debug_users - وضعیت کاربران\n"
                "🧪 /test_send - تست ارسال\n"
                "📁 /check_file - بررسی فایل users.txt\n"
                "📋 /variables - لیست متغیرها\n"
                "🧪 /test_guid - تست ارسال با GUID"
            )
        return

    # ================== خوش‌آمد ادمین ==================
    if IS_ADMIN and sender_guid not in state.admin_greeted:
        level = get_admin_level(sender_guid)
        level_names = {3: "👑 پرو", 4: "💰 مدیر سکه", 2: "⭐ کامل", 1: "📋 محدود"}
        await message.reply(f"✅ {level_names.get(level, 'ادمین')} شناسایی شد!\nسلام سازنده عزیز 👑")
        state.admin_greeted.add(sender_guid)
        save_all_data()

    # ================== کاربر جدید ==================
    if IS_NORMAL and sender_guid not in state.users_notified:
        remove_from_file(PATHS["invalid_guids"], sender_guid)
        remove_from_file(PATHS["invalid_chatids"], chat_id)
        set_user_join_date(sender_guid)
        add_to_total_users(sender_guid)
        
        if "?start=" in (message.text or ""):
            inviter = message.text.split("?start=")[1].strip()
            if inviter and inviter != sender_guid and add_referral(inviter, sender_guid):
                add_coins(inviter, 4)
                if inviter in state.all_users_dict:
                    try:
                        await bot.send_message(state.all_users_dict[inviter],
                            f"🎁 **زیرمجموعه جدید!**\n\n👤 کاربر جدید با لینک شما عضو شد!\n💰 ۴ سکه به حساب شما اضافه شد.\n💎 موجودی فعلی: {get_user_coins(inviter):,} سکه")
                    except:
                        pass
        
        admins = load_admins()
        notification = f"🛎 کاربر جدید وارد بات شد\n\n🆔 GUID:\n{sender_guid}\n💬 Chat ID:\n{chat_id}\n👤 مشخصات:\n{get_user_display(sender_guid)}\n📌 وضعیت:\nدر حال خرید 🛒"
        
        if admins["super_admin"] in state.all_users_dict:
            try:
                await bot.send_message(state.all_users_dict[admins["super_admin"]], notification)
            except:
                pass
        for admin_guid in admins["admins"]:
            if admin_guid in state.all_users_dict:
                try:
                    await bot.send_message(state.all_users_dict[admin_guid], notification)
                except:
                    pass
        
        state.users_notified.add(sender_guid)
        save_all_data()

    # ================== فایل از ادمین ==================
    if IS_ADMIN and not text:
        state.pending_files.append({
            "message_id": message.message_id, "chat_id": chat_id,
            "sender_guid": sender_guid, "time": datetime.now().strftime("%H:%M")
        })
        save_all_data()
        await message.reply(f"📦 فایل دریافت شد\n📁 تعداد کل فایل‌های منتظر: {len(state.pending_files)}\n\n🔹 **برای ارسال فایل:**\nشارژ <Chat ID کاربر>\n\n📝 **نمونه دستور:**\nشارژ {chat_id}")
        return

    # ================== دستورات ادمین ==================
    if IS_ADMIN:
        # ================== دیباگ ==================
        if text == "/debug_users":
            total = len(state.all_users_dict)
            debug_text = f"🔍 **وضعیت کاربران:**\n\nکل: {total} کاربر\n\n"
            for i, (guid, cid) in enumerate(list(state.all_users_dict.items())[:20], 1):
                status = "✅" if cid else "❌"
                debug_text += f"{i}. {status} GUID: {guid[:15]}...\n   Chat ID: {cid or 'ندارد'}\n\n"
            if total > 20:
                debug_text += f"\n... و {total - 20} کاربر دیگر"
            await message.reply(debug_text)
            return
        
        elif text == "/test_send":
            try:
                test_msg = await bot.send_message(chat_id=chat_id, text="🧪 **پیام تست**\n\nاگر این پیام رو می‌بینی، ارسال پیام درسته!")
                await message.reply(f"✅ تست موفق! message_id: {test_msg.message_id}")
            except Exception as e:
                await message.reply(f"❌ تست ناموفق!\n\nخطا: {type(e).__name__}\n{str(e)[:200]}")
            return
        
        elif text == "/test_guid":
            guids = read_guids_from_file()
            if not guids:
                await message.reply("❌ فایل GUID خالیه!")
                return
            
            test_guid = guids[0]
            
            try:
                sent = await bot.send_message(chat_id=test_guid, text="🧪 تست ارسال با GUID")
                await message.reply(f"✅ ارسال با GUID موفق بود!\nGUID: {test_guid}\nmessage_id: {sent.message_id}")
            except Exception as e:
                await message.reply(f"❌ ارسال با GUID ناموفق!\nGUID: {test_guid}\nخطا: {str(e)[:200]}")
            return
        
        elif text == "/check_chatid":
            await message.reply(
                f"📱 **اطلاعات شما:**\n\n"
                f"🆔 GUID: `{sender_guid}`\n"
                f"💬 Chat ID: `{chat_id}`\n"
                f"📊 در دیتابیس: {'✅ ثبت شده' if sender_guid in state.all_users_dict else '❌ ثبت نشده'}"
            )
            return
        
        elif text == "/clear_files":
            for key, path in [
                ("all", PATHS["broadcast_all"]),
                ("file", PATHS["broadcast_file"]),
                ("bot", PATHS["broadcast_bot"])
            ]:
                with open(path, "w", encoding="utf-8") as f:
                    json.dump([], f)
            await message.reply("✅ فایل‌های پیام همگانی خالی شدن!")
            return
        
        elif text == "/sync_total":
            count = sync_total_users()
            await message.reply(f"✅ آمار ترکیبی همگام‌سازی شد!\n📊 تعداد کل: {count:,} نفر")
            return
        
        elif text == "/check_file":
            if os.path.exists(FILE_USERS_PATH):
                guids = read_guids_from_file()
                await message.reply(f"✅ فایل users.txt پیدا شد!\n📁 مسیر: {FILE_USERS_PATH}\n📊 تعداد GUID ها: {len(guids):,}")
            else:
                await message.reply(f"❌ فایل users.txt در مسیر {FILE_USERS_PATH} وجود ندارد!")
            return
        
        elif text == "/variables" and get_admin_level(sender_guid) == 3:
            variables_text = """
📋 **لیست متغیرهای قابل استفاده در متن‌ها:**

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🆔 **اطلاعات کاربر:**
• `{guid}` - شناسه کاربر
• `{chat_id}` - چت آیدی کاربر
• `{name}` - نام کاربر
• `{level}` - سطح کاربر
• `{join_date}` - تاریخ عضویت
• `{membership}` - مدت عضویت

💰 **سکه و امتیازات:**
• `{coins}` - موجودی سکه
• `{referrals}` - تعداد زیرمجموعه

📦 **سرورهای دریافتی:**
• `{files_count}` - تعداد فایل دریافتی
• `{last_file}` - آخرین فایل دریافتی

📊 **آمار ربات:**
• `{total_users}` - کل کاربران یکتا
• `{today_users}` - کاربران امروز
• `{bot_users}` - کاربران ربات
• `{file_users}` - کاربران فایل

📢 **تبلیغات:**
• `{username}` - آیدی کانال
• `{link}` - لینک کانال
• `{duration}` - مدت نمایش (دقیقه)
• `{cost}` - هزینه (سکه)
• `{count}` - تعداد کاربر
• `{position}` - موقعیت در صف
• `{price}` - قیمت هر کاربر
• `{min_users}` - حداقل کاربر
• `{max_users}` - حداکثر کاربر
• `{min_cost}` - حداقل هزینه

🔗 **لینک‌ها:**
• `{activation_link}` - لینک آموزش

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📌 **نحوه استفاده:**
کافیه متغیر رو با `{}` توی متن بذاری.
مثال: `سلام {name}! موجودی شما {coins} سکه است.`

📝 **متن‌های قابل ویرایش:**
• `start` • `prices` • `support` • `tutorial`
• `ad_tutorial` • `free_test` • `cancel_service`
• `why_jaryane` • `free_coins_guide` • `buy_coins`
• `stats` • `ad_template` • `ad_pricing_text`
• `buy_guide`
"""
            await message.reply(variables_text)
            return
        
        elif text == "/mylevel" and IS_ADMIN:
            level = get_admin_level(sender_guid)
            await message.reply(f"سطح شما: {level}")
            return
        
        # ================== دستورات آمار ==================
        if text == "آمار کلی" and can_access_stats(sender_guid):
            guids = read_guids_from_file()
            file_total = len(guids) if guids else 0
            bot_total = len(state.all_users_dict)
            invalid_guids = get_invalid_guids()
            invalid_chatids = get_invalid_chatids()
            valid_file = file_total - len(invalid_guids)
            valid_bot = len([c for c in state.all_users_dict.values() if c and c not in invalid_chatids])
            shared = sum(1 for g in guids if g in state.all_users_dict and state.all_users_dict[g]) if guids else 0
            total_unique = get_total_users_count()
            uptime = int(time.time() - state.bot_start_time)
            hours, rem = divmod(uptime, 3600)
            minutes, seconds = divmod(rem, 60)
            await message.reply(f"""
📊 **آمار کلی ربات (ترکیبی)**
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🤖 **ربات:**
👥 کاربران: {bot_total:,} | ✅ معتبر: {valid_bot:,} | 🚫 ناموفق: {len(invalid_chatids):,}

📁 **فایل users.txt:**
👥 کل: {file_total:,} | ✅ معتبر: {valid_file:,} | ❌ ناموفق: {len(invalid_guids):,}
✅ استارت زده: {shared:,}

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 **ترکیبی:**
👥 کاربران یکتا: {total_unique:,} | 🔄 مشترک: {shared:,}
📨 پیام امروز: {state.daily_stats['messages']} | 💰 فروش: {state.daily_stats['sales']}
⏱️ آپ‌تایم: {hours}h {minutes}m {seconds}s
""")
            return
        
        elif text in ["آمار ربات", "📊 آمار ربات"] and can_access_stats(sender_guid):
            invalid_chatids = get_invalid_chatids()
            valid = len([c for c in state.all_users_dict.values() if c and c not in invalid_chatids])
            await message.reply(f"""
📊 **آمار کاربران ربات**
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
👥 کل کاربران: {len(state.all_users_dict):,}
✅ Chat ID معتبر: {valid:,}
🚫 Chat ID ناموفق: {len(invalid_chatids):,}
📨 پیام‌های امروز: {state.daily_stats['messages']}
👤 کاربران جدید امروز: {len(state.daily_stats['users'])}
""")
            return
        
        elif text in ["آمار فایل", "📊 آمار فایل"] and can_access_stats(sender_guid):
            guids = read_guids_from_file()
            if guids:
                stats = get_file_stats(guids)
                invalid_guids = get_invalid_guids()
                await message.reply(f"""
📊 **آمار کاربران فایل users.txt**
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📁 کل GUID ها: {stats['total']:,}
✅ استارت زده: {stats['started']:,}
⏳ استارت نزده: {stats['not_started']:,}
📈 درصد تبدیل: {stats['percent']}%

✅ GUID معتبر: {stats['total'] - len(invalid_guids):,}
❌ GUID ناموفق: {len(invalid_guids):,}
""")
            else:
                await message.reply("❌ فایل users.txt یافت نشد یا خالی است.")
            return
        
        elif text.startswith("آمار "):
            parts = text.split(" ", 1)
            if len(parts) >= 2:
                target_id = parts[1].strip()
                target_guid = None
                
                if target_id in state.all_users_dict:
                    target_guid = target_id
                else:
                    for guid, cid in state.all_users_dict.items():
                        if cid == target_id:
                            target_guid = guid
                            break
                
                if target_guid:
                    stats = get_user_purchase_stats(target_guid)
                    join_str = get_user_join_date(target_guid)
                    try:
                        jalali_join = jdatetime.datetime.fromgregorian(datetime=datetime.fromisoformat(join_str)).strftime('%Y/%m/%d') if join_str else "نامشخص"
                    except:
                        jalali_join = "نامشخص"
                    level_names = {3: "👑 پرو", 4: "💰 مدیر سکه", 2: "⭐ کامل", 1: "📋 محدود"}
                    user_type = level_names.get(get_admin_level(target_guid), "کاربر عادی") if is_admin(target_guid) else "کاربر عادی"
                    
                    stats_text = f"""
📊 **اطلاعات کاربر**
━━━━━━━━━━━━━━━━
👤 نام: {get_user_name(target_guid)}
🏆 سطح: {get_user_level(target_guid)}
👑 نوع: {user_type}
🆔 GUID: `{target_guid}`
💬 Chat ID: `{state.all_users_dict.get(target_guid, 'نامشخص')}`
━━━━━━━━━━━━━━━━
💰 موجودی: {get_user_coins(target_guid):,} سکه
🎁 کل دریافتی: {get_total_coins_received(target_guid):,}
👥 زیرمجموعه: {get_referral_count(target_guid)} نفر
📦 دریافت: {stats['count']} | آخرین: {stats['last'] or 'ندارد'}
━━━━━━━━━━━━━━━━
📅 عضویت: {jalali_join}
⏱️ سابقه: {get_membership_duration(target_guid)}
"""
                    await message.reply(stats_text)
                else:
                    await message.reply("❌ کاربر یافت نشد.")
            else:
                await message.reply("❌ فرمت: آمار <Chat ID>")
            return
        
        # ================== مدیریت سکه ==================
        elif text.startswith("شارژ سکه ") and can_manage_coins(sender_guid):
            parts = text.split()
            if len(parts) >= 4:
                target_id, amount = parts[2], int(parts[3])
                target_guid = None
                if target_id in state.all_users_dict:
                    target_guid = target_id
                else:
                    for guid, cid in state.all_users_dict.items():
                        if cid == target_id:
                            target_guid = guid
                            break
                
                if target_guid:
                    if is_admin(target_guid) and not can_charge_admins(sender_guid):
                        await message.reply("❌ فقط پرو به ادمین سکه میده.")
                    else:
                        new_bal = add_coins(target_guid, amount)
                        await message.reply(f"✅ **شارژ سکه موفق**\n\n👤 کاربر: {get_user_display(target_guid)}\n💰 مقدار: {amount:,} سکه\n💎 موجودی جدید: {new_bal:,} سکه")
                        if state.all_users_dict.get(target_guid):
                            try:
                                await bot.send_message(state.all_users_dict[target_guid], f"🎁 **شارژ سکه**\n\n💰 {amount:,} سکه به حساب شما اضافه شد!\n💎 موجودی فعلی: {new_bal:,} سکه")
                            except:
                                pass
                else:
                    await message.reply("❌ کاربر یافت نشد.")
            else:
                await message.reply("❌ شارژ سکه <Chat ID> <مقدار>")
            return
        
        elif text.startswith("حذف سکه ") and can_deduct_coins(sender_guid):
            parts = text.split()
            if len(parts) >= 4:
                target_id, amount = parts[2], int(parts[3])
                target_guid = None
                if target_id in state.all_users_dict:
                    target_guid = target_id
                else:
                    for guid, cid in state.all_users_dict.items():
                        if cid == target_id:
                            target_guid = guid
                            break
                
                if target_guid:
                    if is_admin(target_guid) and not can_charge_admins(sender_guid):
                        await message.reply("❌ فقط پرو می‌تواند سکه ادمین را کم کند.")
                    else:
                        if deduct_coins(target_guid, amount):
                            new_bal = get_user_coins(target_guid)
                            await message.reply(f"✅ **حذف سکه موفق**\n\n👤 کاربر: {get_user_display(target_guid)}\n💰 مقدار: {amount:,} سکه\n💎 موجودی جدید: {new_bal:,} سکه")
                            if state.all_users_dict.get(target_guid):
                                try:
                                    await bot.send_message(state.all_users_dict[target_guid], f"📢 **کسر سکه**\n\n💰 {amount:,} سکه از حساب شما کسر شد.\n💎 موجودی فعلی: {new_bal:,} سکه")
                                except:
                                    pass
                        else:
                            await message.reply(f"❌ موجودی کاربر کافی نیست.\n💰 موجودی فعلی: {get_user_coins(target_guid):,} سکه")
                else:
                    await message.reply("❌ کاربر یافت نشد.")
            else:
                await message.reply("❌ فرمت: حذف سکه <Chat ID> <مقدار>")
            return
        
        elif text.startswith("انتقال سکه ") and can_transfer_coins(sender_guid):
            parts = text.split()
            if len(parts) >= 4:
                target_id, amount = parts[2], int(parts[3])
                if get_user_coins(sender_guid) < amount:
                    await message.reply(f"❌ موجودی شما کافی نیست.\n💰 موجودی فعلی: {get_user_coins(sender_guid):,} سکه")
                else:
                    target_guid = None
                    for guid, cid in state.all_users_dict.items():
                        if cid == target_id:
                            target_guid = guid
                            break
                    
                    if target_guid:
                        if is_admin(target_guid) and not can_charge_admins(sender_guid):
                            await message.reply("❌ فقط پرو به ادمین سکه میده.")
                        else:
                            deduct_coins(sender_guid, amount)
                            new_bal = add_coins(target_guid, amount)
                            await message.reply(f"✅ **انتقال سکه موفق**\n\n👤 به: {get_user_display(target_guid)}\n💰 مقدار: {amount:,} سکه\n💎 موجودی جدید شما: {get_user_coins(sender_guid):,} سکه")
                            if state.all_users_dict.get(target_guid):
                                try:
                                    await bot.send_message(state.all_users_dict[target_guid], f"🎁 **دریافت سکه**\n\n💰 {amount:,} سکه از ادمین دریافت کردید!\n💎 موجودی فعلی: {new_bal:,} سکه")
                                except:
                                    pass
                    else:
                        await message.reply("❌ کاربر یافت نشد.")
            else:
                await message.reply("❌ انتقال سکه <Chat ID> <مقدار>")
            return
        
        # ================== ارسال فایل ==================
        elif text.startswith("شارژ "):
            if not state.pending_files:
                await message.reply("❌ هیچ فایلی برای ارسال وجود ندارد\nابتدا فایل را ارسال کنید")
            else:
                parts = text.split()
                if len(parts) >= 2:
                    target = parts[1]
                    success = 0
                    for f in state.pending_files:
                        try:
                            await bot.forward_message(
                                to_chat_id=target,
                                from_chat_id=f["chat_id"],
                                message_id=f["message_id"]
                            )
                            success += 1
                            await asyncio.sleep(0.5)
                        except Exception as e:
                            logger.error(f"Error forwarding file: {e}")
                    
                    if success > 0:
                        target_guid = None
                        for guid, cid in state.all_users_dict.items():
                            if cid == target:
                                target_guid = guid
                                break
                        if target_guid:
                            log_sale(target_guid, 0, "فایل")
                        try:
                            jalali_date = jdatetime.datetime.now().strftime('%Y/%m/%d')
                            await bot.send_message(target, f"جریان ≈ 𝐉𝐚𝐫𝐲𝐚𝐧𝐞\n\n🦋» سرور #جریان با موفقیت فعال شده.\n\n• تاریخ فعال سازی ⏳» {jalali_date}\n\n• پشتیبانی رسمی 🛠» @Supports_Jaryane\n• جهت دریافت رایگان سرور رِندِر‌موج (گیمینگ) به پشتیبانی پیام 💬 دهید.\n\n• خوش استفاده کنید. 🍃🌷")
                        except:
                            pass
                        state.daily_stats["files_sent"] += success
                    await message.reply(f"📊 **گزارش ارسال فایل‌ها**\n\n✅ موفق: {success} فایل\n❌ ناموفق: {len(state.pending_files) - success} فایل")
                    state.pending_files.clear()
                    save_all_data()
            return
        
        # ================== پنل مدیریت ==================
        elif text in ["/panel", "پنل", "منو مدیریت"]:
            level = get_admin_level(sender_guid)
            panel = f"""
🎛️ **پنل مدیریت | سطح {level}**

📊 **آمار و گزارش:**
• آمار کلی - آمار کامل (ربات + فایل)
• آمار ربات - فقط کاربران استارت‌زده
• آمار فایل - فقط کاربران فایل users.txt
• کاربران - لیست کاربران
• آمار <Chat ID> - اطلاعات کامل کاربر

📁 **مدیریت فایل‌ها:**
• فایل بفرستید - ذخیره برای ارسال
• فایل‌های من - مشاهده فایل‌های منتظر
• شارژ <Chat ID> - ارسال فایل به کاربر
• پاک‌سازی فایل‌ها - حذف فایل‌های منتظر
"""
            if can_manage_coins(sender_guid):
                panel += """
💰 **مدیریت سکه:**
• شارژ سکه <Chat ID> <مقدار> - شارژ سکه
• حذف سکه <Chat ID> <مقدار> - کسر سکه
"""
            if can_transfer_coins(sender_guid) and not can_manage_coins(sender_guid):
                panel += "\n💰 **مدیریت سکه (انتقال):**\n• انتقال سکه <Chat ID> <مقدار> - انتقال از موجودی خودت"
            if can_broadcast(sender_guid):
                panel += """
📢 **ارسال همگانی:**
• ارسال همگانی - فقط کاربران ربات
• ارسال به فایل - فقط کاربران فایل
• ارسال به همه - ترکیبی (ربات + فایل)

🗑️ **پاک کردن:**
• پاک کردن پیام همگانی - حذف پیام‌های قبلی
• پاک کردن لیست ناموفق - ریست GUID های ناموفق
• پاک کردن لیست چت آیدی ناموفق - ریست Chat ID های ناموفق
"""
            if can_manage_settings(sender_guid):
                panel += """
⚙️ **تنظیمات:**
• تنظیمات - مشاهده تنظیمات
• تغییر کارت <شماره جدید>
• تغییر نام کارت <نام جدید>
• تغییر قیمت <نام پلن> <قیمت جدید>
"""
            if can_manage_admins(sender_guid):
                panel += """
👑 **مدیریت ادمین‌ها:**
• مدیریت ادمین‌ها - راهنمای کامل
• لیست ادمین‌ها - نمایش همه
• اضافه کردن ادمین <GUID> <نام> <سطح>
• حذف ادمین <GUID>
• تغییر سطح <GUID> <سطح>

📝 **مدیریت متن‌ها:**
• مدیریت متن‌ها - لیست متن‌ها
• مشاهده متن <کلید>
• ویرایش متن <کلید>
• /variables - لیست متغیرها
"""
            if can_manage_ad_settings(sender_guid):
                panel += """
📢 **مدیریت تبلیغات:**
• مدیریت تبلیغات - پنل تبلیغات
• تغییر قیمت تبلیغ <مقدار>
• تغییر حداقل کاربر <مقدار>
• تغییر حداکثر کاربر <مقدار>
• تغییر مدت تبلیغ <دقیقه>
"""
            panel += """
🔍 **دیباگ:**
• /debug_users - وضعیت کاربران
• /test_send - تست ارسال
• /test_guid - تست ارسال با GUID
• /check_chatid - اطلاعات خودت
• /clear_files - خالی کردن فایل‌های پیام همگانی
• /sync_total - همگام‌سازی آمار ترکیبی
• /check_file - بررسی فایل users.txt
• /variables - لیست متغیرها
• /mylevel - نمایش سطح دسترسی
"""
            await message.reply(panel)
            return
        
        # ================== مدیریت تبلیغات (ادمین) ==================
        elif text == "مدیریت تبلیغات" and can_manage_ad_settings(sender_guid):
            await send_with_keyboard(bot, chat_id, "📢 **پنل مدیریت تبلیغات**", create_admin_ad_keyboard())
            return
        
        elif detected == "admin_ad_queue" and can_manage_ad_settings(sender_guid):
            await message.reply(ad_queue.get_queue_info())
            return
        
        elif detected == "admin_ad_active" and can_manage_ad_settings(sender_guid):
            if not ad_queue.active:
                await message.reply("📭 هیچ تبلیغ فعالی وجود ندارد.")
            else:
                ad = ad_queue.active
                elapsed = time.time() - ad.get("start_time", time.time())
                ad_settings = load_ad_settings()
                remaining = max(0, ad_settings['display_duration'] - elapsed)
                minutes = int(remaining // 60)
                seconds = int(remaining % 60)
                
                text_ad = f"""
🔄 **تبلیغ فعال**

🆔 آیدی کانال: {ad.get('username', '')}
🔗 لینک: {ad.get('link', '')}
👤 ثبت‌کننده: {get_user_name(ad['user_guid'])}
👥 ارسال واقعی: {ad['sent_count']} نفر
❌ ناموفق: {ad.get('failed_count', 0)}
⏰ زمان باقی‌مانده: {minutes}:{seconds:02d}
🆔 شناسه: {ad['user_guid']}
"""
                await message.reply(text_ad)
            return
        
        elif detected == "admin_ad_force_next" and can_manage_ad_settings(sender_guid):
            if not ad_queue.active:
                await message.reply("📭 تبلیغ فعالی وجود ندارد.")
            else:
                await message.reply("⏳ در حال حذف تبلیغ فعلی و فعال‌سازی تبلیغ بعدی...")
                await ad_queue.remove_active_ad(bot)
                await message.reply("✅ تبلیغ فعلی حذف شد. تبلیغ بعدی به زودی فعال می‌شود.")
            return
        
        elif detected == "admin_ad_settings" and can_manage_ad_settings(sender_guid):
            ad_settings = load_ad_settings()
            text_ad = f"""
⚙️ **تنظیمات تبلیغات**

💰 قیمت هر کاربر: {ad_settings['price_per_user']} سکه
👥 حداقل کاربر: {ad_settings.get('min_users_per_ad', 10):,}
👥 حداکثر کاربر: {ad_settings['max_users_per_ad']:,}
⏰ مدت نمایش: {ad_settings['display_duration'] // 60} دقیقه

📝 **دستورات تغییر:**
• تغییر قیمت تبلیغ <مقدار>
• تغییر حداقل کاربر <مقدار>
• تغییر حداکثر کاربر <مقدار>
• تغییر مدت تبلیغ <دقیقه>
"""
            await message.reply(text_ad)
            return
        
        elif text.startswith("تغییر قیمت تبلیغ ") and can_manage_ad_settings(sender_guid):
            parts = text.split()
            if len(parts) >= 4:
                try:
                    price = int(parts[3])
                    ad_settings = load_ad_settings()
                    ad_settings["price_per_user"] = price
                    safe_json_save(PATHS["ad_settings"], ad_settings)
                    ad_queue.settings = ad_settings
                    await message.reply(f"✅ قیمت هر کاربر به {price} سکه تغییر کرد.")
                except:
                    await message.reply("❌ مقدار نامعتبر.")
            return
        
        elif text.startswith("تغییر حداقل کاربر ") and can_manage_ad_settings(sender_guid):
            parts = text.split()
            if len(parts) >= 4:
                try:
                    min_users = int(parts[3])
                    ad_settings = load_ad_settings()
                    ad_settings["min_users_per_ad"] = min_users
                    safe_json_save(PATHS["ad_settings"], ad_settings)
                    ad_queue.settings = ad_settings
                    await message.reply(f"✅ حداقل کاربر به {min_users:,} تغییر کرد.")
                except:
                    await message.reply("❌ مقدار نامعتبر.")
            return
        
        elif text.startswith("تغییر حداکثر کاربر ") and can_manage_ad_settings(sender_guid):
            parts = text.split()
            if len(parts) >= 4:
                try:
                    max_users = int(parts[3])
                    ad_settings = load_ad_settings()
                    ad_settings["max_users_per_ad"] = max_users
                    safe_json_save(PATHS["ad_settings"], ad_settings)
                    ad_queue.settings = ad_settings
                    await message.reply(f"✅ حداکثر کاربر به {max_users:,} تغییر کرد.")
                except:
                    await message.reply("❌ مقدار نامعتبر.")
            return
        
        elif text.startswith("تغییر مدت تبلیغ ") and can_manage_ad_settings(sender_guid):
            parts = text.split()
            if len(parts) >= 4:
                try:
                    minutes = int(parts[3])
                    ad_settings = load_ad_settings()
                    ad_settings["display_duration"] = minutes * 60
                    safe_json_save(PATHS["ad_settings"], ad_settings)
                    ad_queue.settings = ad_settings
                    await message.reply(f"✅ مدت نمایش به {minutes} دقیقه تغییر کرد.")
                except:
                    await message.reply("❌ مقدار نامعتبر.")
            return
        
        # ================== ارسال همگانی ==================
        elif text == "ارسال همگانی" and can_broadcast(sender_guid):
            invalid_chatids = get_invalid_chatids()
            valid_users = {
                k: v for k, v in state.all_users_dict.items() 
                if v and v not in invalid_chatids
            }
            
            if not valid_users:
                await message.reply("❌ هیچ کاربر معتبری برای ارسال وجود ندارد")
            else:
                state.user_messages[sender_guid] = {
                    "action": UserAction.AWAITING_BROADCAST_TEXT.value,
                    "valid_users": valid_users,
                    "type": "bot"
                }
                logger.info(f"ارسال همگانی شروع شد - کاربران: {len(valid_users)}")
                await message.reply(
                    f"📝 **متن پیام همگانی را وارد کنید:**\n\n"
                    f"🔵 کاربران معتبر: {len(valid_users):,} نفر\n"
                    f"🟠 نوع: فقط کاربران ربات\n\n"
                    f"❌ برای لغو: /cancel"
                )
            return
        
        elif text in ["ارسال به فایل", "📢 ارسال به فایل"] and can_broadcast(sender_guid):
            guids = read_guids_from_file()
            if not guids:
                await message.reply(f"❌ فایل users.txt یافت نشد یا خالی است.\n📁 مسیر: {FILE_USERS_PATH}")
            else:
                invalid_guids = get_invalid_guids()
                valid_guids = [g for g in guids if g not in invalid_guids]
                
                state.user_messages[sender_guid] = {
                    "action": UserAction.AWAITING_FILE_BROADCAST.value,
                    "guids": valid_guids,
                    "type": "file"
                }
                await message.reply(
                    f"📝 **لطفاً متن پیام همگانی را وارد کنید:**\n\n"
                    f"👥 کل GUID ها: {len(guids):,}\n"
                    f"✅ معتبر: {len(valid_guids):,}\n"
                    f"❌ نامعتبر (قبلاً خطا داده): {len(guids) - len(valid_guids):,}\n\n"
                    f"📌 نوع: فقط کاربران فایل\n"
                    f"❌ لغو: /cancel"
                )
            return
        
        elif text in ["ارسال به همه", "📢 ارسال به همه"] and can_broadcast(sender_guid):
            guids = read_guids_from_file()
            invalid_guids = get_invalid_guids()
            invalid_chatids = get_invalid_chatids()
            
            valid_bot = [
                g for g in state.all_users_dict 
                if state.all_users_dict.get(g) and state.all_users_dict[g] not in invalid_chatids
            ]
            
            # فقط GUID های معتبر (اونایی که توی invalid_guids نیستن)
            valid_file = [g for g in guids if g not in invalid_guids] if guids else []
            
            all_targets = list(set(valid_bot + valid_file))
            total_unique = len(all_targets)
            
            if total_unique == 0:
                await message.reply("❌ هیچ کاربر معتبری برای ارسال وجود ندارد.")
                return
            
            state.user_messages[sender_guid] = {
                "action": UserAction.AWAITING_ALL_BROADCAST.value,
                "targets": all_targets,
                "type": "all"
            }
            
            await message.reply(
                f"📝 **لطفاً متن پیام همگانی را وارد کنید:**\n\n"
                f"🤖 کاربران ربات (معتبر): {len(valid_bot):,}\n"
                f"📁 کاربران فایل (معتبر): {len(valid_file):,}\n"
                f"🔄 مشترک: {len(set(valid_bot) & set(valid_file)):,}\n"
                f"━━━━━━━━━━━━━━━━\n"
                f"🎯 کل یکتا (فقط معتبر): {total_unique:,} نفر\n\n"
                f"📌 نوع: ترکیبی (ربات + فایل)\n"
                f"❌ لغو: /cancel"
            )
            return
        
        # ================== پاک کردن پیام همگانی ==================
        elif text == "پاک کردن پیام همگانی" and can_broadcast(sender_guid):
            stats = {}
            for key, path in [
                ("all", PATHS["broadcast_all"]),
                ("file", PATHS["broadcast_file"]),
                ("bot", PATHS["broadcast_bot"])
            ]:
                if os.path.exists(path):
                    try:
                        with open(path, "r", encoding="utf-8") as f:
                            stats[key] = len(json.load(f))
                    except:
                        stats[key] = 0
                else:
                    stats[key] = 0
            
            menu_text = f"""
🗑️ **پنل پاک کردن پیام‌های همگانی**

📊 **آمار پیام‌های ذخیره شده:**
━━━━━━━━━━━━━━━━━━━━
1️⃣ ارسال به همه: {stats.get('all', 0):,} پیام
2️⃣ ارسال به فایل: {stats.get('file', 0):,} پیام
3️⃣ ارسال همگانی (ربات): {stats.get('bot', 0):,} پیام
━━━━━━━━━━━━━━━━━━━━

🔢 **لطفاً عدد مورد نظر را وارد کنید:**
• 1 = پاک کردن ارسال به همه
• 2 = پاک کردن ارسال به فایل
• 3 = پاک کردن ارسال همگانی

❌ لغو: /cancel
"""
            await message.reply(menu_text)
            state.user_messages[sender_guid] = {
                "action": UserAction.CHOOSE_DELETE_TYPE.value,
                "stats": stats
            }
            return
        
        elif text == "پاک کردن لیست ناموفق" and can_broadcast(sender_guid):
            if os.path.exists(PATHS["invalid_guids"]):
                os.remove(PATHS["invalid_guids"])
            await message.reply("✅ لیست GUID های ناموفق پاک شد.")
            return
        
        elif text == "پاک کردن لیست چت آیدی ناموفق" and can_broadcast(sender_guid):
            if os.path.exists(PATHS["invalid_chatids"]):
                os.remove(PATHS["invalid_chatids"])
            await message.reply("✅ لیست Chat ID های ناموفق پاک شد.")
            return
        
        # ================== مدیریت متن‌ها ==================
        elif text == "مدیریت متن‌ها" and can_manage_admins(sender_guid):
            await message.reply(list_texts())
            return
        
        elif text.startswith("مشاهده متن ") and can_manage_admins(sender_guid):
            key = text.replace("مشاهده متن ", "").strip()
            content = get_text(key)
            if content:
                await message.reply(f"📝 **{key}:**\n\n{content}")
            else:
                await message.reply(f"❌ کلید '{key}' یافت نشد.")
            return
        
        elif text.startswith("ویرایش متن ") and can_manage_admins(sender_guid):
            parts = text.split(" ", 2)
            if len(parts) >= 3:
                key = parts[2].strip()
                if key in DEFAULT_TEXTS:
                    current_text = get_text(key)
                    state.user_messages[sender_guid] = {
                        "action": "awaiting_text_edit",
                        "key": key
                    }
                    await message.reply(
                        f"📝 **متن فعلی {key}:**\n\n"
                        f"{current_text}\n\n"
                        f"━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
                        f"📌 **متن جدید را وارد کنید:**\n"
                        f"(برای لغو: /cancel)"
                    )
                else:
                    await message.reply(f"❌ کلید '{key}' یافت نشد.")
            else:
                await message.reply("❌ فرمت: ویرایش متن <کلید>")
            return
        
        # ================== مدیریت ادمین‌ها ==================
        elif text == "لیست ادمین‌ها" and can_manage_admins(sender_guid):
            await message.reply(list_all_admins())
            return
        
        elif text == "مدیریت ادمین‌ها" and can_manage_admins(sender_guid):
            await message.reply("""👑 **پنل مدیریت ادمین‌ها**

📋 **سطوح دسترسی:**
• سطح ۱ (محدود): آمار + مدیریت فایل
• سطح ۲ (کامل): همه چیز به جز مدیریت ادمین‌ها
• سطح ۳ (پرو): دسترسی نامحدود
• سطح ۴ (مدیر سکه): شارژ/حذف سکه + مدیریت تبلیغات

📝 **دستورات:**
• لیست ادمین‌ها
• اضافه کردن ادمین <GUID> <نام> <سطح>
• حذف ادمین <GUID>
• تغییر سطح <GUID> <سطح جدید>""")
            return
        
        elif text.startswith("اضافه کردن ادمین ") and can_manage_admins(sender_guid):
            parts = text.split()
            if len(parts) >= 6:
                guid = parts[3]
                name = " ".join(parts[4:-1])
                level = int(parts[-1])
                if add_admin(guid, name, level, sender_guid):
                    level_names = {1: "محدود", 2: "کامل", 4: "مدیر سکه"}
                    await message.reply(f"✅ ادمین '{name}' با سطح {level_names.get(level, level)} اضافه شد!\n🆔 `{guid}`")
                else:
                    await message.reply("❌ این ادمین قبلاً اضافه شده یا GUID نامعتبر است.")
            else:
                await message.reply("❌ فرمت: اضافه کردن ادمین <GUID> <نام> <سطح ۱/۲/۴>")
            return
        
        elif text.startswith("حذف ادمین ") and can_manage_admins(sender_guid):
            parts = text.split()
            if len(parts) >= 3:
                guid = parts[2]
                if guid == SUPER_ADMIN_GUID:
                    await message.reply("❌ سازنده پرو قابل حذف نیست!")
                elif remove_admin(guid):
                    await message.reply(f"✅ ادمین با GUID `{guid[:15]}...` حذف شد.")
                else:
                    await message.reply("❌ ادمین یافت نشد.")
            return
        
        elif text.startswith("تغییر سطح ") and can_manage_admins(sender_guid):
            parts = text.split()
            if len(parts) >= 4:
                guid = parts[2]
                new_level = int(parts[3])
                if new_level not in [1, 2, 4]:
                    await message.reply("❌ سطح باید ۱ (محدود)، ۲ (کامل) یا ۴ (مدیر سکه) باشد.")
                elif change_admin_level(guid, new_level):
                    level_names = {1: "محدود", 2: "کامل", 4: "مدیر سکه"}
                    await message.reply(f"✅ سطح دسترسی به '{level_names[new_level]}' تغییر کرد.")
                else:
                    await message.reply("❌ ادمین یافت نشد.")
            else:
                await message.reply("❌ فرمت: تغییر سطح <GUID> <سطح ۱/۲/۴>")
            return
        
        # ================== مدیریت فایل‌ها ==================
        elif text == "کاربران" and can_access_stats(sender_guid):
            if state.all_users_dict:
                users_text = f"👥 **لیست کاربران ({len(state.all_users_dict)})**\n\n"
                for i, (guid, user_chat_id) in enumerate(list(state.all_users_dict.items())[:50], 1):
                    users_text += f"{i}. {get_user_display(guid)}\n"
                    if user_chat_id:
                        users_text += f"   💬 Chat ID: {user_chat_id}\n"
                if len(state.all_users_dict) > 50:
                    users_text += f"\n📊 و {len(state.all_users_dict) - 50} کاربر دیگر..."
            else:
                users_text = "📭 هیچ کاربری ثبت نشده است"
            await message.reply(users_text)
            return
        
        elif text == "فایل‌های من" and can_manage_files(sender_guid):
            if state.pending_files:
                files_text = f"📁 **فایل‌های منتظر ارسال ({len(state.pending_files)})**\n\n"
                for i, f in enumerate(state.pending_files, 1):
                    files_text += f"{i}. زمان: {f.get('time', '---')}\n"
                files_text += f"\n🔹 **برای ارسال:**\nشارژ <Chat ID کاربر>"
            else:
                files_text = "📭 هیچ فایل منتظر ارسالی ندارید"
            await message.reply(files_text)
            return
        
        elif text == "پاک‌سازی فایل‌ها" and can_manage_files(sender_guid):
            count = len(state.pending_files)
            state.pending_files.clear()
            save_all_data()
            await message.reply(f"🗑️ **پاک‌سازی انجام شد**\n\n✅ {count} فایل حذف شد")
            return
        
        # ================== تنظیمات ==================
        elif text == "تنظیمات" and can_manage_settings(sender_guid):
            sets = load_settings()
            txt = f"⚙️ **تنظیمات فعلی:**\n\n💳 کارت: {sets['card_number']}\n👤 به نام: {sets['card_name']}\n\n💰 **قیمت‌ها:**\n"
            for plan, price in sets['prices'].items():
                txt += f"{plan}: {price:,} تومان\n"
            await message.reply(txt)
            return
        
        elif text.startswith("تغییر کارت ") and can_manage_settings(sender_guid):
            parts = text.split(" ", 2)
            if len(parts) >= 3:
                new_card = parts[2].strip()
                sets = load_settings()
                sets["card_number"] = new_card
                save_settings(sets)
                await message.reply(f"✅ شماره کارت به `{new_card}` تغییر کرد.")
            else:
                await message.reply("❌ فرمت: تغییر کارت <شماره جدید>")
            return
        
        elif text.startswith("تغییر نام کارت ") and can_manage_settings(sender_guid):
            parts = text.split(" ", 3)
            if len(parts) >= 4:
                new_name = parts[3].strip()
                sets = load_settings()
                sets["card_name"] = new_name
                save_settings(sets)
                await message.reply(f"✅ نام دارنده به `{new_name}` تغییر کرد.")
            else:
                await message.reply("❌ فرمت: تغییر نام کارت <نام جدید>")
            return
        
        elif text.startswith("تغییر قیمت ") and can_manage_settings(sender_guid):
            parts = text.split(" ")
            if len(parts) >= 4:
                plan = parts[2]
                try:
                    price = int(parts[3])
                    sets = load_settings()
                    if plan in sets["prices"]:
                        sets["prices"][plan] = price
                        save_settings(sets)
                        await message.reply(f"✅ قیمت {plan} به {price:,} تومان تغییر کرد.")
                    else:
                        await message.reply(f"❌ پلن '{plan}' یافت نشد. پلن‌ها: {', '.join(sets['prices'].keys())}")
                except:
                    await message.reply("❌ قیمت باید عدد باشد.")
            else:
                await message.reply("❌ فرمت: تغییر قیمت <نام پلن> <قیمت جدید>")
            return

    # ================== مدیریت حالت ==================
    if sender_guid in state.user_messages:
        action = state.user_messages[sender_guid].get("action")
        data = state.user_messages[sender_guid]
        
        logger.info(f"پردازش state برای {sender_guid}: action={action}")
        
        # ویرایش متن
        if action == "awaiting_text_edit":
            if text == "/cancel":
                await message.reply("❌ لغو شد.")
                del state.user_messages[sender_guid]
                return
            
            key = data["key"]
            
            try:
                texts = load_texts()
                texts[key] = text
                save_texts(texts)
                await message.reply(f"✅ **متن {key} با موفقیت ویرایش شد!**")
            except Exception as e:
                logger.error(f"Error editing text: {e}")
                await message.reply("❌ خطا در ویرایش متن.")
            
            del state.user_messages[sender_guid]
            return
        
        # پاک کردن پیام
        elif action == UserAction.CHOOSE_DELETE_TYPE.value:
            if text == "/cancel":
                await message.reply("❌ لغو شد.")
                del state.user_messages[sender_guid]
                return
            
            type_map = {
                "1": "all", "۱": "all",
                "2": "file", "۲": "file",
                "3": "bot", "۳": "bot"
            }
            
            if text in type_map:
                broadcast_type = type_map[text]
                
                if data.get("stats", {}).get(broadcast_type, 0) == 0:
                    type_names = {'all': 'ارسال به همه', 'file': 'ارسال به فایل', 'bot': 'ارسال همگانی'}
                    await message.reply(f"❌ هیچ پیامی از نوع '{type_names[broadcast_type]}' برای پاک کردن وجود ندارد.")
                    del state.user_messages[sender_guid]
                    return
                
                await delete_broadcast_messages(bot, chat_id, broadcast_type)
                del state.user_messages[sender_guid]
            else:
                await message.reply("❌ گزینه نامعتبر. لطفاً ۱، ۲ یا ۳ را وارد کنید.")
            return
        
        # ارسال به فایل
        elif action == UserAction.AWAITING_FILE_BROADCAST.value:
            if text.lower() == "/cancel":
                await message.reply("❌ لغو شد.")
                del state.user_messages[sender_guid]
                return
            
            await broadcast_with_progress(
                bot=bot,
                chat_id=chat_id,
                targets=data["guids"],
                text=text,
                broadcast_type="file"
            )
            del state.user_messages[sender_guid]
            save_all_data()
            return
        
        # ارسال به همه
        elif action == UserAction.AWAITING_ALL_BROADCAST.value:
            if text.lower() == "/cancel":
                await message.reply("❌ لغو شد.")
                del state.user_messages[sender_guid]
                return
            
            await broadcast_with_progress(
                bot=bot,
                chat_id=chat_id,
                targets=data["targets"],
                text=text,
                broadcast_type="all"
            )
            del state.user_messages[sender_guid]
            save_all_data()
            return
        
        # ارسال همگانی (ربات)
        elif action == UserAction.AWAITING_BROADCAST_TEXT.value:
            if text.lower() == "/cancel":
                await message.reply("❌ لغو شد.")
                del state.user_messages[sender_guid]
                return
            
            valid_users = data["valid_users"]
            await broadcast_with_progress(
                bot=bot,
                chat_id=chat_id,
                targets=list(valid_users.keys()),
                text=text,
                broadcast_type="bot"
            )
            del state.user_messages[sender_guid]
            save_all_data()
            return
        
        # ثبت تبلیغ - مرحله ۱: آیدی کانال
        elif action == UserAction.AWAITING_AD_LINK.value:
            if text == "/cancel":
                await send_with_keyboard(bot, chat_id, "❌ لغو شد.", create_ad_panel_keyboard())
                del state.user_messages[sender_guid]
                return
            
            username = text.strip()
            if not username.startswith("@"):
                await message.reply("❌ آیدی باید با @ شروع شود!\n📌 مثال: @MY_MILADM")
                return
            
            if len(username) < 4:
                await message.reply("❌ آیدی خیلی کوتاه است!")
                return
            
            if not re.match(r'^@[a-zA-Z0-9_]+$', username):
                await message.reply("❌ آیدی فقط می‌تواند شامل حروف انگلیسی، اعداد و _ باشد!")
                return
            
            link = f"https://rubika.ir/{username[1:]}"
            
            state.user_messages[sender_guid] = {
                "action": UserAction.AWAITING_AD_COUNT.value,
                "username": username,
                "link": link
            }
            
            ad_settings = load_ad_settings()
            await message.reply(
                f"🆔 آیدی ثبت شد: {username}\n\n"
                f"👥 **چند کاربر می‌خواهید تبلیغ شما را ببینند؟**\n\n"
                f"📌 حداقل: {ad_settings.get('min_users_per_ad', 10):,} | حداکثر: {ad_settings['max_users_per_ad']:,}\n"
                f"💰 هزینه: {ad_settings['price_per_user']} سکه به ازای هر کاربر\n\n"
                f"🔢 **لطفاً تعداد را وارد کنید:**\n"
                f"❌ لغو: /cancel"
            )
            return
        
        # ثبت تبلیغ - مرحله ۲: تعداد
        elif action == UserAction.AWAITING_AD_COUNT.value:
            if text == "/cancel":
                await send_with_keyboard(bot, chat_id, "❌ لغو شد.", create_ad_panel_keyboard())
                del state.user_messages[sender_guid]
                return
            
            try:
                count = int(text)
            except:
                await message.reply("❌ لطفاً یک عدد معتبر وارد کنید.")
                return
            
            ad_settings = load_ad_settings()
            min_users = ad_settings.get('min_users_per_ad', 10)
            if count < min_users:
                await message.reply(f"❌ حداقل تعداد {min_users:,} کاربر است.")
                return
            if count > ad_settings['max_users_per_ad']:
                await message.reply(f"❌ حداکثر تعداد {ad_settings['max_users_per_ad']:,} کاربر است.")
                return
            
            username = data["username"]
            link = data["link"]
            cost = count * ad_settings['price_per_user']
            user_coins = get_user_coins(sender_guid)
            
            state.user_messages[sender_guid] = {
                "action": UserAction.AWAITING_AD_CONFIRM.value,
                "username": username,
                "link": link,
                "count": count,
                "cost": cost
            }
            
            await message.reply(
                f"📋 **تأیید سفارش تبلیغ**\n\n"
                f"🆔 آیدی کانال: {username}\n"
                f"🔗 لینک: {link}\n"
                f"👥 تعداد کاربر: {count:,} نفر\n"
                f"💰 هزینه: {cost:,} سکه\n"
                f"💎 موجودی شما: {user_coins:,} سکه\n\n"
                f"⏰ مدت نمایش: {ad_settings['display_duration'] // 60} دقیقه\n"
                f"📌 موقعیت در صف: {len(ad_queue.queue) + 1}\n\n"
                f"✅ **آیا تأیید می‌کنید؟**\n"
                f"برای تأیید: 'بله' | برای لغو: /cancel"
            )
            return
        
        # ثبت تبلیغ - مرحله ۳: تأیید
        elif action == UserAction.AWAITING_AD_CONFIRM.value:
            if text == "/cancel" or text.lower() != "بله":
                await send_with_keyboard(bot, chat_id, "❌ لغو شد.", create_ad_panel_keyboard())
                del state.user_messages[sender_guid]
                return
            
            username = data["username"]
            link = data["link"]
            count = data["count"]
            cost = data["cost"]
            
            if not deduct_coins(sender_guid, cost):
                await message.reply(f"❌ موجودی سکه شما کافی نیست.\n💰 نیاز: {cost:,} | موجودی: {get_user_coins(sender_guid):,}")
                del state.user_messages[sender_guid]
                return
            
            ad_data = {
                "user_guid": sender_guid,
                "username": username,
                "link": link,
                "target_count": count,
                "cost": cost
            }
            position = ad_queue.add_to_queue(ad_data)
            
            ad_settings = load_ad_settings()
            await message.reply(
                f"✅ **تبلیغ شما با موفقیت ثبت شد!**\n\n"
                f"🆔 آیدی کانال: {username}\n"
                f"👥 سفارش: {count:,} نفر\n"
                f"💰 هزینه پرداخت شده: {cost:,} سکه\n"
                f"📊 موقعیت در صف: {position}\n\n"
                f"⏳ تبلیغ شما در نوبت نمایش قرار گرفت.\n"
                f"📢 هنگام فعال‌سازی به شما اطلاع داده می‌شود."
            )
            
            await send_with_keyboard(bot, chat_id, "📍 به منوی اصلی بازگشتید.")
            del state.user_messages[sender_guid]
            return
        
        # تغییر نام
        elif action == UserAction.AWAITING_NAME_CHANGE.value:
            if len(text) > 50:
                await message.reply("❌ حداکثر ۵۰ کاراکتر.")
            else:
                set_user_name(sender_guid, text)
                await send_with_keyboard(bot, chat_id, f"✅ نام به '{text}' تغییر کرد.", create_profile_keyboard())
                del state.user_messages[sender_guid]
            return
        
        # ثبت کد دعوت
        elif action == UserAction.AWAITING_REFERRAL_CODE.value:
            if text == "/cancel":
                await send_with_keyboard(bot, chat_id, "❌ لغو شد.", create_free_coins_keyboard())
                del state.user_messages[sender_guid]
            else:
                inviter_guid = text.strip()
                if inviter_guid not in state.all_users_dict:
                    await message.reply("❌ کد دعوت نامعتبر است!")
                elif inviter_guid == sender_guid:
                    await message.reply("❌ کد خودت رو نمیتونی وارد کنی!")
                elif add_referral(inviter_guid, sender_guid):
                    add_coins(inviter_guid, 4)
                    add_coins(sender_guid, 2)
                    my_coins = get_user_coins(sender_guid)
                    await message.reply(f"✅ کد ثبت شد!\n🎁 ۲ سکه به تو اضافه شد.\n💎 موجودی: {my_coins:,}")
                    
                    if inviter_guid in state.all_users_dict:
                        try:
                            await bot.send_message(
                                state.all_users_dict[inviter_guid],
                                f"🎁 زیرمجموعه جدید!\n💰 ۴ سکه اضافه شد.\n💎 موجودی: {get_user_coins(inviter_guid):,}"
                            )
                        except:
                            pass
                else:
                    await message.reply("❌ قبلاً ثبت شده.")
                
                await send_with_keyboard(bot, chat_id, "", create_free_coins_keyboard())
                del state.user_messages[sender_guid]
            return

    # ================== پاسخ پیش‌فرض ==================
    if text and IS_NORMAL:
        await send_with_keyboard(bot, chat_id, "لطفاً از دکمه‌های زیر استفاده کنید:")
    
    # مدیریت دستورات نامعتبر
    if text.startswith("/") and sender_guid not in state.user_messages:
        await message.reply("❌ دستور نامعتبر!\n📋 /panel - لیست دستورات")
        return

# ================== پردازش خودکار صف تبلیغات ==================
async def start_ad_queue_processor():
    await ad_queue.process_queue(bot)

# ================== پایان ==================
atexit.register(save_all_data)
logger.info("✅ ربات آماده کار است.")
logger.info(f"🎯 آمار: {get_total_users_count()} کاربر")
logger.info("📁 تمام قابلیت‌ها فعال هستند")

async def main():
    """تابع اصلی اجرای ربات"""
    asyncio.create_task(start_ad_queue_processor())
    await bot.run()

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        logger.info("🛑 ربات متوقف شد.")
    except Exception as e:
        logger.error(f"❌ خطای بحرانی: {e}")()