from rubka import Robot
from datetime import datetime
import json
import time
import os
import re
import asyncio

TOKEN = "FIAAI0PZKCDTKJYLSUSFELLMRLURFGODSAMFCTDOYFUDFQOHVVPNTUJUACDAWKSR"

CREATORS = [
    "b0I5rgt0Pax0d15f8a7577e3057687f3",
    "b0IqQJc0Pax01bab861fc1397eb4be81"
]

GROUP_DATA_FILE = "group_bot_data.json"
FONT_ADMINS_FILE = "font_admins.json"
ADS_CONFIG_FILE = "ads_config.json"
BOT_STATUS_FILE = "bot_status.json"
SCHEDULED_MSG_FILE = "scheduled_message.json"

BOLD_FONT = {
    'A': '𝗔', 'B': '𝗕', 'C': '𝗖', 'D': '𝗗', 'E': '𝗘', 'F': '𝗙', 'G': '𝗚',
    'H': '𝗛', 'I': '𝗜', 'J': '𝗝', 'K': '𝗞', 'L': '𝗟', 'M': '𝗠', 'N': '𝗡',
    'O': '𝗢', 'P': '𝗣', 'Q': '𝗤', 'R': '𝗥', 'S': '𝗦', 'T': '𝗧', 'U': '𝗨',
    'V': '𝗩', 'W': '𝗪', 'X': '𝗫', 'Y': '𝗬', 'Z': '𝗭',
    'a': '𝗮', 'b': '𝗯', 'c': '𝗰', 'd': '𝗱', 'e': '𝗲', 'f': '𝗳', 'g': '𝗴',
    'h': '𝗵', 'i': '𝗶', 'j': '𝗷', 'k': '𝗸', 'l': '𝗹', 'm': '𝗺', 'n': '𝗻',
    'o': '𝗼', 'p': '𝗽', 'q': '𝗾', 'r': '𝗿', 's': '𝘀', 't': '𝘁', 'u': '𝘂',
    'v': '𝘃', 'w': '𝘄', 'x': '𝘅', 'y': '𝘆', 'z': '𝘇',
    '0': '𝟬', '1': '𝟭', '2': '𝟮', '3': '𝟯', '4': '𝟰', '5': '𝟱', '6': '𝟲',
    '7': '𝟳', '8': '𝟴', '9': '𝟵',
    ' ': ' '
}

SPECIAL_CHARS = {'<', '>', '‹', '›', '․', '↵', '✦'}

# ================== توابع داده ==================
def load_scheduled_message():
    try:
        if os.path.exists(SCHEDULED_MSG_FILE):
            with open(SCHEDULED_MSG_FILE, 'r', encoding='utf-8') as f:
                return json.load(f)
    except:
        pass
    return {"enabled": False, "group_id": "", "message": "", "time": "00:00", "last_sent": None}

def save_scheduled_message(data):
    try:
        with open(SCHEDULED_MSG_FILE, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
    except:
        pass

def load_bot_status():
    try:
        if os.path.exists(BOT_STATUS_FILE):
            with open(BOT_STATUS_FILE, 'r', encoding='utf-8') as f:
                data = json.load(f)
                return data.get("active", True)
    except:
        pass
    return True

def save_bot_status(active):
    try:
        with open(BOT_STATUS_FILE, 'w', encoding='utf-8') as f:
            json.dump({"active": active, "last_change": datetime.now().isoformat()}, f, ensure_ascii=False, indent=2)
    except:
        pass

def load_group_data():
    try:
        if os.path.exists(GROUP_DATA_FILE):
            with open(GROUP_DATA_FILE, 'r', encoding='utf-8') as f:
                data = json.load(f)
                return data.get('groups', []), data.get('stats', {})
    except:
        pass
    return [], {"total_messages": 0, "last_broadcast": None, "start_time": datetime.now().strftime('%Y/%m/%d %H:%M:%S')}

def save_group_data(groups, stats):
    try:
        data = {'groups': groups, 'stats': stats, 'last_save': datetime.now().strftime('%Y/%m/%d %H:%M:%S')}
        with open(GROUP_DATA_FILE, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
    except:
        pass

def load_font_admins():
    try:
        if os.path.exists(FONT_ADMINS_FILE):
            with open(FONT_ADMINS_FILE, 'r', encoding='utf-8') as f:
                return json.load(f)
    except:
        pass
    data = {"creators": CREATORS, "admins": []}
    save_font_admins(data)
    return data

def save_font_admins(admins):
    try:
        with open(FONT_ADMINS_FILE, 'w', encoding='utf-8') as f:
            json.dump(admins, f, ensure_ascii=False, indent=2)
    except:
        pass

def load_ads_config():
    try:
        if os.path.exists(ADS_CONFIG_FILE):
            with open(ADS_CONFIG_FILE, 'r', encoding='utf-8') as f:
                return json.load(f)
    except:
        pass
    return {"enabled": False, "message": "", "interval_minutes": 60, "last_sent": None}

def save_ads_config(config):
    try:
        with open(ADS_CONFIG_FILE, 'w', encoding='utf-8') as f:
            json.dump(config, f, ensure_ascii=False, indent=2)
    except:
        pass

def is_creator(user_id):
    return str(user_id) in CREATORS

def is_font_admin(user_id):
    admins = load_font_admins()
    user_str = str(user_id)
    if user_str in CREATORS:
        return True
    return user_str in admins.get("admins", [])

def get_user_title(user_id):
    user_str = str(user_id)
    if user_str == CREATORS[0]:
        return "👑 سازنده اول"
    elif user_str == CREATORS[1]:
        return "👑 سازنده دوم"
    elif is_font_admin(user_id) and not is_creator(user_id):
        return "👨‍💼 ادمین فونت"
    return "👤 کاربر عادی"

def to_bold(text):
    result = ""
    for char in text:
        if char in SPECIAL_CHARS:
            result += char
        elif char in BOLD_FONT:
            result += BOLD_FONT[char]
        elif char.upper() in BOLD_FONT:
            result += BOLD_FONT[char.upper()]
        else:
            result += char
    return result

def is_english(text):
    return bool(re.match(r'^[A-Za-z0-9\s]+$', text))

def get_button_id(msg):
    if hasattr(msg, 'raw_data') and msg.raw_data:
        aux = msg.raw_data.get('aux_data', {})
        return aux.get('button_id')
    return None

def has_file(msg):
    if hasattr(msg, 'file') and msg.file is not None:
        return True
    if hasattr(msg, 'has_media') and msg.has_media:
        return True
    return False

async def reply_kb(msg, text, keyboard):
    try:
        await msg.reply(text, chat_keypad=keyboard)
    except:
        try:
            await msg.reply(text, chat_keypad=keyboard, chat_keypad_type="New")
        except:
            await msg.reply(text)
            # ================== کیبوردها ==================

def kb_font_admin():
    """ادمین فونت - ۶ دکمه"""
    return {
        "rows": [
            {"buttons": [
                {"id": "moon_font", "type": "Simple", "button_text": "🌙 شعبه یک (ماه)"},
                {"id": "star_font", "type": "Simple", "button_text": "⭐ شعبه دو (ستاره)"}
            ]},
            {"buttons": [
                {"id": "font_test", "type": "Simple", "button_text": "🧪 تست فونت"},
                {"id": "font_help", "type": "Simple", "button_text": "📚 راهنما"}
            ]},
            {"buttons": [
                {"id": "my_id", "type": "Simple", "button_text": "🆔 شناسه من"},
                {"id": "cancel_font", "type": "Simple", "button_text": "🔄 انصراف"}
            ]}
        ],
        "resize_keyboard": True, "one_time_keyboard": False
    }

def kb_creator_main(bot_active=True):
    """سازنده - منوی اصلی"""
    toggle_text = "🟢 فعال (کلیک برای غیرفعال)" if bot_active else "🔴 غیرفعال (کلیک برای فعال)"
    return {
        "rows": [
            {"buttons": [
                {"id": "send_message", "type": "Simple", "button_text": "📢 ارسال پیام به گروه‌ها"},
                {"id": "send_file", "type": "Simple", "button_text": "📁 ارسال فایل"}
            ]},
            {"buttons": [
                {"id": "group_list", "type": "Simple", "button_text": "📋 لیست گروه‌ها"},
                {"id": "user_list", "type": "Simple", "button_text": "👤 لیست کاربران"}
            ]},
            {"buttons": [
                {"id": "add_group", "type": "Simple", "button_text": "➕ افزودن گروه"},
                {"id": "remove_group", "type": "Simple", "button_text": "➖ حذف گروه"}
            ]},
            {"buttons": [
                {"id": "bot_stats", "type": "Simple", "button_text": "📊 آمار ربات"},
                {"id": "ads_management", "type": "Simple", "button_text": "📣 مدیریت تبلیغات"}
            ]},
            {"buttons": [
                {"id": "font_section", "type": "Simple", "button_text": "✨ بخش فونت"},
                {"id": "admin_management", "type": "Simple", "button_text": "👥 مدیریت ادمین‌ها"}
            ]},
            {"buttons": [
                {"id": "creator_help", "type": "Simple", "button_text": "📚 راهنما"},
                {"id": "toggle_bot", "type": "Simple", "button_text": toggle_text}
            ]}
        ],
        "resize_keyboard": True, "one_time_keyboard": False
    }

def kb_back_only():
    """فقط دکمه بازگشت"""
    return {
        "rows": [[{"buttons": [{"id": "back_to_main", "type": "Simple", "button_text": "🔙 بازگشت به منوی اصلی"}]}]],
        "resize_keyboard": True, "one_time_keyboard": False
    }

def kb_send_file():
    """کیبورد ارسال فایل"""
    return {
        "rows": [
            {"buttons": [
                {"id": "send_file_to_groups", "type": "Simple", "button_text": "📢 ارسال به همه گروه‌ها"},
                {"id": "send_file_to_user", "type": "Simple", "button_text": "👤 ارسال به کاربر خاص"}
            ]},
            {"buttons": [
                {"id": "back_to_main", "type": "Simple", "button_text": "🔙 بازگشت"}
            ]}
        ],
        "resize_keyboard": True, "one_time_keyboard": False
    }

def kb_ads_management():
    """مدیریت تبلیغات"""
    return {
        "rows": [
            {"buttons": [
                {"id": "set_ads_text", "type": "Simple", "button_text": "📝 تنظیم متن تبلیغ"},
                {"id": "set_ads_time", "type": "Simple", "button_text": "⏰ تنظیم زمان"}
            ]},
            {"buttons": [
                {"id": "scheduled_message", "type": "Simple", "button_text": "🕐 ارسال زمان‌بندی شده"}
            ]},
            {"buttons": [
                {"id": "start_ads", "type": "Simple", "button_text": "▶️ شروع تبلیغات"},
                {"id": "stop_ads", "type": "Simple", "button_text": "⏸️ توقف تبلیغات"}
            ]},
            {"buttons": [
                {"id": "send_ads_now", "type": "Simple", "button_text": "📢 ارسال فوری"},
                {"id": "ads_status", "type": "Simple", "button_text": "📊 وضعیت تبلیغات"}
            ]},
            {"buttons": [
                {"id": "back_to_main", "type": "Simple", "button_text": "🔙 بازگشت"}
            ]}
        ],
        "resize_keyboard": True, "one_time_keyboard": False
    }

def kb_scheduled_message():
    """کیبورد ارسال زمان‌بندی شده"""
    return {
        "rows": [
            {"buttons": [
                {"id": "set_sch_group", "type": "Simple", "button_text": "👥 تنظیم گوید گروه مقصد"},
                {"id": "set_sch_text", "type": "Simple", "button_text": "📝 تنظیم متن پیام"}
            ]},
            {"buttons": [
                {"id": "set_sch_time", "type": "Simple", "button_text": "🕐 تنظیم ساعت ارسال"}
            ]},
            {"buttons": [
                {"id": "start_sch", "type": "Simple", "button_text": "▶️ فعال کردن"},
                {"id": "stop_sch", "type": "Simple", "button_text": "⏸️ غیرفعال کردن"}
            ]},
            {"buttons": [
                {"id": "sch_status", "type": "Simple", "button_text": "📊 وضعیت"},
                {"id": "back_to_ads", "type": "Simple", "button_text": "🔙 بازگشت"}
            ]}
        ],
        "resize_keyboard": True, "one_time_keyboard": False
    }

def kb_back_to_ads():
    """بازگشت به تبلیغات"""
    return {
        "rows": [[{"buttons": [{"id": "back_to_ads", "type": "Simple", "button_text": "🔙 بازگشت"}]}]],
        "resize_keyboard": True, "one_time_keyboard": False
    }

def kb_font_section():
    """بخش فونت برای سازنده"""
    return {
        "rows": [
            {"buttons": [
                {"id": "moon_font", "type": "Simple", "button_text": "🌙 شعبه یک (ماه)"},
                {"id": "star_font", "type": "Simple", "button_text": "⭐ شعبه دو (ستاره)"}
            ]},
            {"buttons": [
                {"id": "font_test", "type": "Simple", "button_text": "🧪 تست فونت"},
                {"id": "font_help", "type": "Simple", "button_text": "📚 راهنما فونت"}
            ]},
            {"buttons": [
                {"id": "back_to_main", "type": "Simple", "button_text": "🔙 بازگشت"}
            ]}
        ],
        "resize_keyboard": True, "one_time_keyboard": False
    }

def kb_admin_management():
    """مدیریت ادمین‌ها"""
    return {
        "rows": [
            {"buttons": [
                {"id": "add_admin", "type": "Simple", "button_text": "➕ افزودن ادمین فونت"},
                {"id": "remove_admin", "type": "Simple", "button_text": "➖ حذف ادمین فونت"}
            ]},
            {"buttons": [
                {"id": "admin_list", "type": "Simple", "button_text": "📋 لیست ادمین‌ها"},
                {"id": "back_to_main", "type": "Simple", "button_text": "🔙 بازگشت"}
            ]}
        ],
        "resize_keyboard": True, "one_time_keyboard": False
    }
    # ================== کلاس اصلی ==================
class SuperBot:
    def __init__(self):
        self.bot = Robot(TOKEN)
        self.groups, self.group_stats = load_group_data()
        self.font_admins = load_font_admins()
        self.is_running = True
        self.bot_active = load_bot_status()
        self.user_states = {}
        self.user_notified = set()
        self.creator_chat_ids = {}
        self.pending_files = []

    def save_all_data(self):
        save_group_data(self.groups, self.group_stats)
        save_font_admins(self.font_admins)

    def toggle_bot(self):
        self.bot_active = not self.bot_active
        save_bot_status(self.bot_active)
        return self.bot_active

    async def scheduled_message_loop(self):
        """حلقه ارسال زمان‌بندی شده - هر ۳۰ ثانیه چک می‌کنه"""
        while self.is_running:
            try:
                if self.bot_active:
                    sch = load_scheduled_message()
                    if sch.get("enabled") and sch.get("group_id") and sch.get("message") and sch.get("time"):
                        now = datetime.now().strftime("%H:%M")
                        target_time = sch.get("time", "00:00")
                        last_sent = sch.get("last_sent")
                        today = datetime.now().strftime("%Y-%m-%d")
                        should_send = False
                        
                        if now == target_time:
                            if last_sent is None:
                                should_send = True
                            else:
                                last_date = last_sent[:10] if len(last_sent) >= 10 else ""
                                if last_date != today:
                                    should_send = True
                        
                        if should_send:
                            try:
                                await self.bot.send_message(sch["group_id"], sch["message"])
                                sch["last_sent"] = datetime.now().isoformat()
                                save_scheduled_message(sch)
                                print(f"🕐 پیام زمان‌بندی شده به {sch['group_id'][:10]}... ارسال شد")
                                # اطلاع به سازنده‌ها
                                for cid in self.creator_chat_ids.values():
                                    try:
                                        await self.bot.send_message(cid,
                                            f"🕐 **پیام زمان‌بندی شده ارسال شد**\n\n"
                                            f"👥 گروه: `{sch['group_id'][:15]}...`\n"
                                            f"🕐 ساعت: {target_time}\n"
                                            f"📝 متن: {sch['message'][:50]}..."
                                        )
                                    except:
                                        pass
                            except:
                                print(f"❌ خطا در ارسال زمان‌بندی به {sch['group_id'][:10]}...")
                await asyncio.sleep(30)
            except:
                await asyncio.sleep(30)

    async def auto_ads_loop(self):
        """حلقه تبلیغات خودکار"""
        while self.is_running:
            try:
                if self.bot_active:
                    config = load_ads_config()
                    if config.get("enabled") and config.get("message") and self.groups:
                        last_sent = config.get("last_sent")
                        interval = config.get("interval_minutes", 60)
                        should_send = False
                        if last_sent is None:
                            should_send = True
                        else:
                            try:
                                time_diff = (datetime.now() - datetime.fromisoformat(last_sent)).total_seconds() / 60
                                should_send = time_diff >= interval
                            except:
                                should_send = True
                        if should_send:
                            message = config["message"]
                            print(f"\n📢 ارسال تبلیغ خودکار به {len(self.groups)} گروه...")
                            s, f = 0, 0
                            for group in self.groups:
                                try:
                                    await self.bot.send_message(group, message)
                                    s += 1
                                    await asyncio.sleep(0.5)
                                except:
                                    f += 1
                            config["last_sent"] = datetime.now().isoformat()
                            save_ads_config(config)
                            self.group_stats["total_messages"] += s
                            self.group_stats["last_broadcast"] = {
                                "text": message[:50], "time": datetime.now().strftime('%H:%M:%S'),
                                "success": s, "failed": f, "type": "auto_ads"
                            }
                            self.save_all_data()
                            for cid in self.creator_chat_ids.values():
                                try:
                                    await self.bot.send_message(cid, f"📢 تبلیغ خودکار:\n✅ {s} | ❌ {f}")
                                except:
                                    pass
                await asyncio.sleep(60)
            except:
                await asyncio.sleep(60)

    async def forward_file_to(self, from_chat, msg_id, to_chat):
        try:
            await self.bot.forward_message(to_chat_id=to_chat, from_chat_id=from_chat, message_id=msg_id)
            return True
        except:
            return False

    def get_full_stats(self):
        config = load_ads_config()
        ads_status = "✅ فعال" if config.get("enabled") else "⏸️ غیرفعال"
        bot_status = "🟢 فعال" if self.bot_active else "🔴 غیرفعال"
        uptime = datetime.now() - datetime.strptime(self.group_stats['start_time'], '%Y/%m/%d %H:%M:%S')
        hours, remainder = divmod(int(uptime.total_seconds()), 3600)
        minutes, _ = divmod(remainder, 60)
        
        stats = (
            f"📊 **آمار کامل ربات**\n\n"
            f"🤖 **وضعیت ربات:** {bot_status}\n"
            f"👥 **گروه‌ها:** {len(self.groups)}\n"
            f"📨 **کل پیام‌ها:** {self.group_stats['total_messages']}\n"
            f"👨‍💼 **ادمین‌های فونت:** {len(self.font_admins.get('admins', []))}\n"
            f"👤 **کاربران:** {len(self.user_notified)}\n"
            f"📁 **فایل‌های منتظر:** {len(self.pending_files)}\n"
            f"📣 **تبلیغات:** {ads_status}\n"
            f"⏰ **فاصله:** هر {config.get('interval_minutes', 60)} دقیقه\n"
            f"🕐 **شروع:** {self.group_stats['start_time']}\n"
            f"⏱️ **آپتایم:** {hours}h {minutes}m\n"
            f"⏰ **اکنون:** {datetime.now().strftime('%H:%M:%S')}"
        )
        
        if self.group_stats.get('last_broadcast'):
            last = self.group_stats['last_broadcast']
            stats += (
                f"\n\n📢 **آخرین ارسال:**\n"
                f"• متن: {last.get('text', '---')}\n"
                f"• زمان: {last.get('time', '---')}\n"
                f"• نوع: {last.get('type', 'دستی')}\n"
                f"• ✅ موفق: {last.get('success', 0)}\n"
                f"• ❌ ناموفق: {last.get('failed', 0)}"
            )
        
        return stats

    async def notify_creators(self, message):
        for cid in self.creator_chat_ids.values():
            try:
                await self.bot.send_message(cid, message)
            except:
                pass
                       
    def run(self):
        print("\n" + "="*60)
        print("🤖 سوپرربات ترکیبی - نسخه کامل نهایی")
        print("="*60)
        print(f"👑 سازنده اول: {CREATORS[0][:15]}...")
        print(f"👑 سازنده دوم: {CREATORS[1][:15]}...")
        print(f"👥 گروه‌ها: {len(self.groups)}")
        print(f"👨‍💼 ادمین‌های فونت: {len(self.font_admins.get('admins', []))}")
        print(f"🤖 وضعیت: {'🟢 فعال' if self.bot_active else '🔴 غیرفعال'}")
        print(f"⏰ {datetime.now().strftime('%H:%M:%S')}")
        print("\n📋 **تمام قابلیت‌ها:**")
        print("  ✅ کاربر عادی: فقط شناسه")
        print("  ✅ ادمین فونت: ۶ دکمه فونت")
        print("  ✅ سازنده: ۱۲ دکمه + زیرمنوها")
        print("  ✅ ارسال پیام و فایل")
        print("  ✅ تبلیغات خودکار")
        print("  ✅ 🕐 ارسال زمان‌بندی شده (جدید)")
        print("  ✅ لیست گروه‌ها و کاربران")
        print("  ✅ راهنما در هر بخش")
        print("  ✅ فعال/غیرفعال کردن ربات")
        print("="*60)
        print("\n✅ ربات آماده...")

        @self.bot.on_message()
        async def handler(bot, msg):
            if not msg.is_private:
                return

            sender = msg.chat_id
            text = (msg.text or "").strip()
            button_id = get_button_id(msg)
            is_file = has_file(msg)
            msg_id = msg.message_id

            if is_creator(sender):
                self.creator_chat_ids[sender] = sender

            # ===== دکمه تغییر وضعیت =====
            if button_id == "toggle_bot" and is_creator(sender):
                new_status = self.toggle_bot()
                if new_status:
                    await reply_kb(msg,
                        "🟢 **ربات فعال شد!**\n\n"
                        "✅ همه کاربران می‌تونن از ربات استفاده کنن\n"
                        "✅ تبلیغات خودکار و زمان‌بندی فعال میشه\n"
                        "✅ ارسال پیام و فایل امکان‌پذیره",
                        kb_creator_main(new_status)
                    )
                else:
                    await reply_kb(msg,
                        "🔴 **ربات غیرفعال شد!**\n\n"
                        "❌ فقط سازنده‌ها می‌تونن استفاده کنن\n"
                        "❌ کاربران عادی پیام «ربات غیرفعال» می‌گیرن\n"
                        "❌ تبلیغات خودکار و زمان‌بندی متوقف میشه\n\n"
                        "🟢 برای فعال‌سازی دوباره کلیک کنید",
                        kb_creator_main(new_status)
                    )
                return

            # ===== ربات غیرفعال - فقط سازنده =====
            if not self.bot_active and not is_creator(sender):
                if text or button_id or is_file:
                    await msg.reply(
                        "🔴 **ربات در حال حاضر غیرفعال است**\n\n"
                        "⏰ لطفاً بعداً تلاش کنید\n"
                        "📞 در صورت نیاز به پشتیبانی پیام بدید"
                    )
                return

            # ===== دریافت فایل از سازنده =====
            if is_creator(sender) and is_file and not text:
                file_type = "فایل"
                if hasattr(msg, 'file') and msg.file:
                    try:
                        if hasattr(msg.file, 'file_type'):
                            file_type = msg.file.file_type
                    except:
                        pass
                
                self.pending_files.append({
                    "message_id": msg_id,
                    "chat_id": sender,
                    "type": file_type,
                    "time": datetime.now().strftime("%H:%M:%S"),
                    "timestamp": time.time()
                })
                
                await reply_kb(msg,
                    f"📁 **فایل دریافت شد!**\n\n"
                    f"📦 **نوع فایل:** {file_type}\n"
                    f"📊 **تعداد فایل‌های منتظر:** {len(self.pending_files)}\n\n"
                    f"🎯 **حالا مقصد را انتخاب کنید:**\n"
                    f"• 📢 ارسال به همه گروه‌ها\n"
                    f"• 👤 ارسال به کاربر خاص\n\n"
                    f"⚠️ فایل‌های قدیمی‌تر از ۱۰ دقیقه حذف می‌شوند",
                    kb_send_file()
                )
                return

            # ===== کاربر عادی: فقط شناسه =====
            if not is_creator(sender) and not is_font_admin(sender):
                if sender not in self.user_notified:
                    self.user_notified.add(sender)
                    await self.notify_creators(
                        f"🛎 **کاربر جدید وارد ربات شد**\n\n"
                        f"🆔 Chat ID: `{sender}`\n"
                        f"👤 نوع: {get_user_title(sender)}\n"
                        f"⏰ زمان: {datetime.now().strftime('%H:%M:%S')}\n"
                        f"📊 کل کاربران: {len(self.user_notified)}"
                    )
                
                if text or button_id or is_file:
                    await msg.reply(
                        f"🆔 **شناسه شما:**\n\n"
                        f"`{sender}`\n\n"
                        f"👤 **نوع کاربر:** {get_user_title(sender)}\n\n"
                        f"💡 این شناسه را برای سازنده ربات ارسال کنید"
                    )
                return

            # ===== مدیریت state های انتظار =====
            if sender in self.user_states:
                state = self.user_states[sender]
                step = state.get("step")
                
                # ========== انتظار اسم فونت ==========
                if step == "waiting_name":
                    name = text.strip().upper() if text else ""
                    kb = kb_font_admin() if is_font_admin(sender) and not is_creator(sender) else kb_font_section()
                    
                    if not name:
                        await reply_kb(msg,
                            "❌ **اسم نمی‌تواند خالی باشد!**\n\n"
                            "✍️ **لطفاً اسم انگلیسی خود را بنویسید:**\n"
                            "• فقط حروف انگلیسی و اعداد\n"
                            "• حداکثر ۲۰ کاراکتر\n"
                            "• مثال: ALI, REZA, TEST123\n\n"
                            "🔄 برای انصراف دکمه انصراف را بزنید",
                            kb
                        )
                        return
                    if len(name) > 20:
                        await reply_kb(msg,
                            "❌ **حداکثر ۲۰ کاراکتر مجاز است!**\n\n"
                            f"اسم شما {len(name)} کاراکتر دارد\n"
                            "✍️ **لطفاً اسم کوتاه‌تری بنویسید:**",
                            kb
                        )
                        return
                    if not is_english(name):
                        await reply_kb(msg,
                            "❌ **فقط حروف انگلیسی و اعداد مجاز است!**\n\n"
                            "✍️ **لطفاً اسم انگلیسی بنویسید:**\n"
                            "مثال: ALI, REZA, TEST123",
                            kb
                        )
                        return
                    
                    template = state.get("template", "🌙")
                    bold_name = to_bold(name)
                    result = f"✦{bold_name}‹{template}›․↵"
                    del self.user_states[sender]
                    
                    kb = kb_font_admin() if is_font_admin(sender) and not is_creator(sender) else kb_creator_main(self.bot_active)
                    await reply_kb(msg,
                        f"✅ **فونت شما با موفقیت ساخته شد!**\n\n"
                        f"📝 **جزئیات فونت:**\n"
                        f"• 🌙 شعبه: {template}\n"
                        f"• 🔤 اسم اصلی: `{name}`\n"
                        f"• 💪 اسم بولد: `{bold_name}`\n\n"
                        f"📋 **متن آماده کپی:**\n"
                        f"`{result}`\n\n"
                        f"👁️ **پیش‌نمایش:**\n"
                        f"{result}\n\n"
                        f"🔄 برای ساخت فونت جدید از دکمه‌ها استفاده کنید\n"
                        f"📋 می‌تونید متن بالا رو کپی کنید",
                        kb
                    )
                    return
                
                # ========== انتظار متن تبلیغ ==========
                elif step == "waiting_ads_text":
                    if text:
                        config = load_ads_config()
                        config["message"] = text
                        save_ads_config(config)
                        del self.user_states[sender]
                        await reply_kb(msg,
                            f"✅ **متن تبلیغ با موفقیت تنظیم شد!**\n\n"
                            f"📝 **متن جدید:**\n"
                            f"{text[:300]}{'...' if len(text) > 300 else ''}\n\n"
                            f"📊 **طول متن:** {len(text)} کاراکتر\n\n"
                            f"💡 حالا می‌تونید تبلیغات رو شروع کنید",
                            kb_ads_management()
                        )
                    else:
                        await reply_kb(msg,
                            "❌ **متن نمی‌تواند خالی باشد!**\n\n"
                            "📝 **لطفاً متن تبلیغ را وارد کنید:**\n"
                            "می‌تونید از ایموجی و قالب‌بندی استفاده کنید",
                            kb_back_to_ads()
                        )
                    return
                
                # ========== انتظار زمان تبلیغ ==========
                elif step == "waiting_ads_time":
                    try:
                        minutes = int(text)
                        if 1 <= minutes <= 1440:
                            config = load_ads_config()
                            config["interval_minutes"] = minutes
                            save_ads_config(config)
                            del self.user_states[sender]
                            
                            if minutes < 60:
                                time_text = f"{minutes} دقیقه"
                            elif minutes == 60:
                                time_text = "1 ساعت"
                            elif minutes < 1440:
                                time_text = f"{minutes // 60} ساعت و {minutes % 60} دقیقه"
                            else:
                                time_text = "24 ساعت (1 روز)"
                            
                            await reply_kb(msg,
                                f"✅ **زمان تبلیغ با موفقیت تنظیم شد!**\n\n"
                                f"⏰ **فاصله زمانی:** هر {minutes} دقیقه\n"
                                f"🕐 **معادل:** {time_text}\n\n"
                                f"📢 تبلیغ به صورت خودکار در این بازه زمانی ارسال می‌شود",
                                kb_ads_management()
                            )
                        else:
                            await reply_kb(msg,
                                "❌ **زمان باید بین 1 تا 1440 دقیقه باشد!**\n\n"
                                "⏰ **لطفاً دوباره وارد کنید:**\n"
                                "• حداقل: 1 دقیقه\n"
                                "• حداکثر: 1440 دقیقه (24 ساعت)\n"
                                "• مثال: 60",
                                kb_back_to_ads()
                            )
                    except:
                        await reply_kb(msg,
                            "❌ **لطفاً یک عدد معتبر وارد کنید!**\n\n"
                            "⏰ **مثال:** 60\n"
                            "این عدد نشان‌دهنده فاصله بین تبلیغات به دقیقه است",
                            kb_back_to_ads()
                        )
                    return
                
                # ========== انتظار متن ارسال همگانی ==========
                elif step == "waiting_broadcast":
                    if text and self.groups:
                        await msg.reply(f"⏳ **در حال ارسال پیام به {len(self.groups)} گروه...**\n\nلطفاً صبر کنید...")
                        s, f = 0, 0
                        failed_groups = []
                        for g in self.groups:
                            try:
                                await bot.send_message(g, text)
                                s += 1
                                await asyncio.sleep(0.3)
                            except:
                                f += 1
                                failed_groups.append(g)
                        
                        self.group_stats["total_messages"] += s
                        self.group_stats["last_broadcast"] = {
                            "text": text[:50], "time": datetime.now().strftime('%H:%M:%S'),
                            "success": s, "failed": f, "type": "manual"
                        }
                        self.save_all_data()
                        del self.user_states[sender]
                        
                        result_text = (
                            f"✅ **ارسال پیام انجام شد!**\n\n"
                            f"📊 **نتیجه ارسال:**\n"
                            f"• ✅ موفق: {s} گروه\n"
                            f"• ❌ ناموفق: {f} گروه\n"
                            f"• 📁 کل گروه‌ها: {len(self.groups)}\n\n"
                            f"📝 **متن ارسالی:**\n"
                            f"{text[:150]}{'...' if len(text) > 150 else ''}"
                        )
                        
                        if failed_groups and len(failed_groups) <= 5:
                            result_text += f"\n\n❌ **گروه‌های ناموفق:**\n"
                            for fg in failed_groups:
                                result_text += f"• `{fg}`\n"
                        
                        await reply_kb(msg, result_text, kb_creator_main(self.bot_active))
                    
                    elif not self.groups:
                        del self.user_states[sender]
                        await reply_kb(msg,
                            "❌ **هیچ گروهی ثبت نشده است!**\n\n"
                            "➕ ابتدا از دکمه «افزودن گروه» استفاده کنید\n"
                            "💡 گوید گروه را از بخش «🆔 شناسه من» دریافت کنید",
                            kb_creator_main(self.bot_active)
                        )
                    return
                
                # ========== انتظار گوید برای افزودن گروه ==========
                elif step == "waiting_add_group":
                    if text:
                        if text in self.groups:
                            del self.user_states[sender]
                            await reply_kb(msg,
                                f"✅ **این گروه قبلاً اضافه شده است!**\n\n"
                                f"🆔: `{text}`\n"
                                f"📊 **کل گروه‌ها:** {len(self.groups)}\n\n"
                                f"💡 برای مشاهده همه گروه‌ها از «📋 لیست گروه‌ها» استفاده کنید",
                                kb_creator_main(self.bot_active)
                            )
                        else:
                            self.groups.append(text)
                            self.save_all_data()
                            del self.user_states[sender]
                            await reply_kb(msg,
                                f"✅ **گروه با موفقیت اضافه شد!**\n\n"
                                f"🆔 **گوید گروه:** `{text}`\n"
                                f"📊 **کل گروه‌ها:** {len(self.groups)}\n\n"
                                f"💡 حالا می‌تونید به این گروه پیام یا فایل ارسال کنید",
                                kb_creator_main(self.bot_active)
                            )
                    return
                
                # ========== انتظار گوید برای حذف گروه ==========
                elif step == "waiting_remove_group":
                    if text:
                        if text in self.groups:
                            self.groups.remove(text)
                            self.save_all_data()
                            del self.user_states[sender]
                            await reply_kb(msg,
                                f"🗑️ **گروه با موفقیت حذف شد!**\n\n"
                                f"🆔 **گوید حذف شده:** `{text}`\n"
                                f"📊 **باقی‌مانده:** {len(self.groups)} گروه",
                                kb_creator_main(self.bot_active)
                            )
                        else:
                            del self.user_states[sender]
                            await reply_kb(msg,
                                "❌ **این گروه در لیست وجود ندارد!**\n\n"
                                "📋 لطفاً گوید را به درستی وارد کنید\n"
                                "💡 می‌توانید از «📋 لیست گروه‌ها» گویدها را ببینید",
                                kb_creator_main(self.bot_active)
                            )
                    return
                
                # ========== انتظار آیدی برای ارسال فایل ==========
                elif step == "waiting_file_target":
                    if text and self.pending_files:
                        target = text.strip()
                        await msg.reply(f"⏳ **در حال ارسال {len(self.pending_files)} فایل به کاربر...**")
                        s, f = 0, 0
                        for pf in self.pending_files:
                            if await self.forward_file_to(pf["chat_id"], pf["message_id"], target):
                                s += 1
                            else:
                                f += 1
                            await asyncio.sleep(0.3)
                        
                        self.group_stats["total_messages"] += s
                        self.save_all_data()
                        self.pending_files.clear()
                        del self.user_states[sender]
                        await reply_kb(msg,
                            f"✅ **ارسال فایل انجام شد!**\n\n"
                            f"📁 **تعداد فایل‌ها:** {s + f}\n"
                            f"• ✅ موفق: {s}\n"
                            f"• ❌ ناموفق: {f}\n"
                            f"👤 **کاربر مقصد:** `{target}`",
                            kb_creator_main(self.bot_active)
                        )
                    return
                
                # ========== انتظار آیدی برای افزودن ادمین ==========
                elif step == "waiting_add_admin":
                    if text:
                        if text in CREATORS:
                            del self.user_states[sender]
                            await reply_kb(msg,
                                "❌ **این کاربر سازنده است و دسترسی کامل دارد!**\n\n"
                                "👑 سازنده‌ها به صورت خودکار به همه بخش‌ها دسترسی دارند",
                                kb_admin_management()
                            )
                        elif text in self.font_admins.get("admins", []):
                            del self.user_states[sender]
                            await reply_kb(msg,
                                f"✅ **این کاربر قبلاً ادمین فونت است!**\n\n"
                                f"🆔: `{text}`\n"
                                f"📊 **تعداد ادمین‌ها:** {len(self.font_admins['admins'])}",
                                kb_admin_management()
                            )
                        else:
                            self.font_admins.setdefault("admins", []).append(text)
                            save_font_admins(self.font_admins)
                            del self.user_states[sender]
                            await reply_kb(msg,
                                f"✅ **ادمین فونت با موفقیت اضافه شد!**\n\n"
                                f"🆔 **آیدی ادمین جدید:** `{text}`\n"
                                f"📊 **تعداد ادمین‌ها:** {len(self.font_admins['admins'])}\n\n"
                                f"👨‍💼 این کاربر حالا می‌تونه از بخش فونت استفاده کنه",
                                kb_admin_management()
                            )
                    return
                
                # ========== انتظار آیدی برای حذف ادمین ==========
                elif step == "waiting_remove_admin":
                    if text:
                        if text in self.font_admins.get("admins", []):
                            self.font_admins["admins"].remove(text)
                            save_font_admins(self.font_admins)
                            del self.user_states[sender]
                            await reply_kb(msg,
                                f"🗑️ **ادمین فونت با موفقیت حذف شد!**\n\n"
                                f"🆔 **آیدی حذف شده:** `{text}`\n"
                                f"📊 **باقی‌مانده:** {len(self.font_admins['admins'])} ادمین",
                                kb_admin_management()
                            )
                        else:
                            del self.user_states[sender]
                            await reply_kb(msg,
                                "❌ **این کاربر ادمین فونت نیست!**\n\n"
                                "📋 لطفاً آیدی را به درستی وارد کنید\n"
                                "💡 می‌توانید از «📋 لیست ادمین‌ها» آیدی‌ها را ببینید",
                                kb_admin_management()
                            )
                    return
                
                # ========== انتظارات زمان‌بندی ==========
                elif step == "waiting_sch_group":
                    if text:
                        sch = load_scheduled_message()
                        sch["group_id"] = text
                        save_scheduled_message(sch)
                        del self.user_states[sender]
                        await reply_kb(msg,
                            f"✅ **گوید گروه مقصد تنظیم شد!**\n\n"
                            f"👥 **گروه:** `{text}`\n\n"
                            f"💡 حالا متن و ساعت رو تنظیم کنید",
                            kb_scheduled_message()
                        )
                    return
                
                elif step == "waiting_sch_text":
                    if text:
                        sch = load_scheduled_message()
                        sch["message"] = text
                        save_scheduled_message(sch)
                        del self.user_states[sender]
                        await reply_kb(msg,
                            f"✅ **متن پیام تنظیم شد!**\n\n"
                            f"📝 **متن:**\n{text[:200]}{'...' if len(text) > 200 else ''}",
                            kb_scheduled_message()
                        )
                    else:
                        await reply_kb(msg,
                            "❌ **متن نمی‌تواند خالی باشد!**\n\n"
                            "📝 لطفاً متن پیام را وارد کنید:",
                            kb_back_to_ads()
                        )
                    return
                
                elif step == "waiting_sch_time":
                    if text and re.match(r'^\d{2}:\d{2}$', text):
                        sch = load_scheduled_message()
                        sch["time"] = text
                        sch["last_sent"] = None
                        save_scheduled_message(sch)
                        del self.user_states[sender]
                        await reply_kb(msg,
                            f"✅ **ساعت ارسال تنظیم شد!**\n\n"
                            f"🕐 **ساعت:** {text}\n"
                            f"📅 هر روز در این ساعت پیام ارسال می‌شود",
                            kb_scheduled_message()
                        )
                    else:
                        await reply_kb(msg,
                            "❌ **فرمت ساعت صحیح نیست!**\n\n"
                            "🕐 **لطفاً به این فرمت وارد کنید:**\n"
                            "• مثال: 00:00\n"
                            "• مثال: 08:30\n"
                            "• مثال: 23:59",
                            kb_back_to_ads()
                        )
                    return

            # ===== کلیک دکمه‌ها =====
            if button_id and button_id != "toggle_bot":
                print(f"🎯 دکمه: {button_id} | کاربر: {sender[:10]}...")
                
                # ---- دکمه‌های فونت (مشترک) ----
                if button_id == "moon_font":
                    self.user_states[sender] = {"step": "waiting_name", "template": "🌙"}
                    kb = kb_font_admin() if is_font_admin(sender) and not is_creator(sender) else kb_font_section()
                    await reply_kb(msg,
                        "✅ **شعبه یک (ماه) انتخاب شد** 🌙\n\n"
                        "✍️ **اسم انگلیسی خود را بنویسید:**\n"
                        "• فقط حروف انگلیسی و اعداد\n"
                        "• حداکثر ۲۰ کاراکتر\n"
                        "• مثال: ALI, REZA, TEST123\n\n"
                        "📋 **قالب نهایی:** ✦اسم‹🌙›․↵\n\n"
                        "🔄 برای انصراف دکمه انصراف را بزنید",
                        kb
                    )
                    return
                
                elif button_id == "star_font":
                    self.user_states[sender] = {"step": "waiting_name", "template": "⭐"}
                    kb = kb_font_admin() if is_font_admin(sender) and not is_creator(sender) else kb_font_section()
                    await reply_kb(msg,
                        "✅ **شعبه دو (ستاره) انتخاب شد** ⭐\n\n"
                        "✍️ **اسم انگلیسی خود را بنویسید:**\n"
                        "• فقط حروف انگلیسی و اعداد\n"
                        "• حداکثر ۲۰ کاراکتر\n"
                        "• مثال: ALI, REZA, TEST123\n\n"
                        "📋 **قالب نهایی:** ✦اسم‹⭐›․↵\n\n"
                        "🔄 برای انصراف دکمه انصراف را بزنید",
                        kb
                    )
                    return
                
                elif button_id == "font_test":
                    bold_name = to_bold("ALI")
                    kb = kb_font_admin() if is_font_admin(sender) and not is_creator(sender) else kb_font_section()
                    await reply_kb(msg,
                        f"🧪 **تست فونت**\n\n"
                        f"🔤 **اسم اصلی:** ALI\n"
                        f"💪 **اسم بولد:** {bold_name}\n\n"
                        f"📋 **نمونه‌های خروجی:**\n\n"
                        f"🌙 **شعبه یک (ماه):**\n"
                        f"`✦{bold_name}‹🌙›․↵`\n\n"
                        f"⭐ **شعبه دو (ستاره):**\n"
                        f"`✦{bold_name}‹⭐›․↵`\n\n"
                        f"💡 برای تبدیل اسم خود، یکی از شعبه‌ها را انتخاب کنید",
                        kb
                    )
                    return
                
                elif button_id == "font_help":
                    kb = kb_font_admin() if is_font_admin(sender) and not is_creator(sender) else kb_font_section()
                    await reply_kb(msg,
                        "📚 **راهنمای بخش فونت**\n\n"
                        "🎯 **دکمه‌ها و کاربرد:**\n"
                        "• 🌙 **شعبه یک** - ساخت فونت با ماه\n"
                        "• ⭐ **شعبه دو** - ساخت فونت با ستاره\n"
                        "• 🧪 **تست** - پیش‌نمایش فونت با اسم ALI\n"
                        "• 🆔 **شناسه** - دریافت شناسه کاربری\n"
                        "• 🔄 **انصراف** - لغو عملیات فعلی\n\n"
                        "📋 **قالب‌های نهایی:**\n"
                        "• شعبه یک: ✦اسم‹🌙›․↵\n"
                        "• شعبه دو: ✦اسم‹⭐›․↵\n\n"
                        "💡 **نحوه استفاده:**\n"
                        "1. یکی از شعبه‌ها را انتخاب کنید\n"
                        "2. اسم انگلیسی خود را بنویسید\n"
                        "3. متن آماده شده را کپی کنید",
                        kb
                    )
                    return
                
                elif button_id == "my_id":
                    kb = kb_font_admin() if is_font_admin(sender) and not is_creator(sender) else kb_font_section()
                    await reply_kb(msg,
                        f"🆔 **شناسه کاربری شما**\n\n"
                        f"`{sender}`\n\n"
                        f"👤 **نوع کاربر:** {get_user_title(sender)}\n\n"
                        f"💡 این شناسه را برای سازنده ربات ارسال کنید",
                        kb
                    )
                    return
                
                elif button_id == "cancel_font":
                    if sender in self.user_states:
                        del self.user_states[sender]
                    kb = kb_font_admin() if is_font_admin(sender) and not is_creator(sender) else kb_creator_main(self.bot_active)
                    await reply_kb(msg,
                        "🔄 **عملیات با موفقیت لغو شد**\n\n"
                        "✅ می‌توانید دوباره از دکمه‌ها استفاده کنید",
                        kb
                    )
                    return
                
                # ---- دکمه‌های سازنده ----
                if is_creator(sender):
                    # ===== ارسال پیام =====
                    if button_id == "send_message":
                        self.user_states[sender] = {"step": "waiting_broadcast"}
                        await reply_kb(msg,
                            f"📢 **ارسال پیام همگانی**\n\n"
                            f"👥 **تعداد گروه‌های هدف:** {len(self.groups)}\n"
                            f"📝 **متن پیام خود را وارد کنید:**\n\n"
                            f"💡 پیام به تمام گروه‌های ثبت شده ارسال خواهد شد\n"
                            f"🔙 برای بازگشت دکمه بازگشت را بزنید",
                            kb_back_only()
                        )
                        return
                    
                    # ===== ارسال فایل =====
                    elif button_id == "send_file":
                        if self.pending_files:
                            await reply_kb(msg,
                                f"📁 **{len(self.pending_files)} فایل منتظر ارسال**\n\n"
                                f"🎯 **مقصد را انتخاب کنید:**\n"
                                f"• 📢 ارسال به همه گروه‌ها\n"
                                f"• 👤 ارسال به کاربر خاص",
                                kb_send_file()
                            )
                        else:
                            await reply_kb(msg,
                                "📁 **ارسال فایل**\n\n"
                                "📤 **فایل خود را بفرستید** (عکس، ویدیو، سند...)\n"
                                "سپس از این منو مقصد را انتخاب کنید\n\n"
                                "⚠️ **توجه:** فایلی یافت نشد - ابتدا فایل را ارسال کنید",
                                kb_send_file()
                            )
                        return
                    
                    elif button_id == "send_file_to_groups":
                        if not self.pending_files:
                            await reply_kb(msg,
                                "❌ **فایلی برای ارسال وجود ندارد!**\n\n"
                                "📤 ابتدا فایل را بفرستید",
                                kb_creator_main(self.bot_active)
                            )
                        elif not self.groups:
                            await reply_kb(msg,
                                "❌ **هیچ گروهی ثبت نشده!**\n\n"
                                "➕ ابتدا گروه اضافه کنید",
                                kb_creator_main(self.bot_active)
                            )
                        else:
                            await msg.reply(f"⏳ **در حال ارسال {len(self.pending_files)} فایل به {len(self.groups)} گروه...**")
                            s, f = 0, 0
                            for pf in self.pending_files:
                                for g in self.groups:
                                    if await self.forward_file_to(pf["chat_id"], pf["message_id"], g):
                                        s += 1
                                    else:
                                        f += 1
                                    await asyncio.sleep(0.2)
                            self.group_stats["total_messages"] += s
                            self.save_all_data()
                            self.pending_files.clear()
                            await reply_kb(msg,
                                f"✅ **فایل‌ها با موفقیت ارسال شدند!**\n\n"
                                f"📁 **تعداد فایل‌ها:** {s + f}\n"
                                f"• ✅ موفق: {s}\n"
                                f"• ❌ ناموفق: {f}\n"
                                f"👥 **گروه‌های هدف:** {len(self.groups)}",
                                kb_creator_main(self.bot_active)
                            )
                        return
                    
                    elif button_id == "send_file_to_user":
                        if not self.pending_files:
                            await reply_kb(msg,
                                "❌ **فایلی برای ارسال وجود ندارد!**\n\n"
                                "📤 ابتدا فایل را بفرستید",
                                kb_creator_main(self.bot_active)
                            )
                        else:
                            self.user_states[sender] = {"step": "waiting_file_target"}
                            await reply_kb(msg,
                                f"👤 **ارسال فایل به کاربر خاص**\n\n"
                                f"📁 **{len(self.pending_files)} فایل آماده ارسال**\n\n"
                                f"📝 **Chat ID کاربر را وارد کنید:**\n"
                                f"💡 کاربر باید شناسه خود را از دکمه «🆔 شناسه من» دریافت کرده باشد",
                                kb_back_only()
                            )
                        return
                    
                    # ===== لیست گروه‌ها =====
                    elif button_id == "group_list":
                        if self.groups:
                            txt = f"📋 **لیست گروه‌های ثبت شده**\n\n"
                            txt += f"📊 **تعداد کل:** {len(self.groups)} گروه\n\n"
                            for i, g in enumerate(self.groups, 1):
                                txt += f"{i}. `{g}`\n"
                            txt += f"\n💡 برای افزودن/حذف گروه از دکمه‌های مربوطه استفاده کنید"
                        else:
                            txt = (
                                "📭 **هیچ گروهی ثبت نشده است**\n\n"
                                "➕ با دکمه «افزودن گروه» گروه جدید اضافه کنید\n"
                                "💡 گوید گروه را از بخش «🆔 شناسه من» دریافت کنید"
                            )
                        await reply_kb(msg, txt, kb_creator_main(self.bot_active))
                        return
                    
                    # ===== لیست کاربران =====
                    elif button_id == "user_list":
                        if self.user_notified:
                            txt = f"👤 **لیست کاربران وارد شده به ربات**\n\n"
                            txt += f"📊 **تعداد کل:** {len(self.user_notified)} کاربر\n\n"
                            for i, uid in enumerate(list(self.user_notified)[:30], 1):
                                txt += f"{i}. `{uid}`\n"
                            if len(self.user_notified) > 30:
                                txt += f"\n... و {len(self.user_notified) - 30} کاربر دیگر"
                        else:
                            txt = "📭 **هنوز هیچ کاربری وارد ربات نشده است**"
                        await reply_kb(msg, txt, kb_creator_main(self.bot_active))
                        return
                    
                    # ===== افزودن گروه =====
                    elif button_id == "add_group":
                        self.user_states[sender] = {"step": "waiting_add_group"}
                        await reply_kb(msg,
                            "➕ **افزودن گروه جدید**\n\n"
                            "📝 **گوید (Chat ID) گروه را وارد کنید:**\n\n"
                            "💡 **راهنما:**\n"
                            "• گوید گروه را می‌توانید از دکمه «🆔 شناسه من» دریافت کنید\n"
                            "• پس از افزودن، می‌توانید به گروه پیام ارسال کنید\n"
                            "🔙 برای بازگشت دکمه بازگشت را بزنید",
                            kb_back_only()
                        )
                        return
                    
                    # ===== حذف گروه =====
                    elif button_id == "remove_group":
                        if self.groups:
                            txt = f"➖ **حذف گروه**\n\n"
                            txt += f"📋 **گروه‌های موجود ({len(self.groups)}):**\n"
                            for i, g in enumerate(self.groups[:10], 1):
                                txt += f"{i}. `{g}`\n"
                            if len(self.groups) > 10:
                                txt += f"... و {len(self.groups) - 10} گروه دیگر\n"
                            txt += f"\n📝 **گوید گروه مورد نظر را برای حذف وارد کنید:**"
                            self.user_states[sender] = {"step": "waiting_remove_group"}
                            await reply_kb(msg, txt, kb_back_only())
                        else:
                            await reply_kb(msg,
                                "📭 **هیچ گروهی برای حذف وجود ندارد**",
                                kb_creator_main(self.bot_active)
                            )
                        return
                    
                    # ===== آمار =====
                    elif button_id == "bot_stats":
                        await reply_kb(msg, self.get_full_stats(), kb_creator_main(self.bot_active))
                        return
                    
                    # ===== مدیریت تبلیغات =====
                    elif button_id == "ads_management":
                        config = load_ads_config()
                        status = "✅ فعال" if config.get("enabled") else "⏸️ غیرفعال"
                        msg_text = config.get("message", "")
                        sch = load_scheduled_message()
                        sch_st = "✅ فعال" if sch.get("enabled") else "⏸️ غیرفعال"
                        await reply_kb(msg,
                            f"📣 **مدیریت تبلیغات**\n\n"
                            f"📢 **تبلیغات خودکار:** {status}\n"
                            f"⏰ **فاصله:** هر {config.get('interval_minutes', 60)} دقیقه\n"
                            f"📝 **متن:** {msg_text[:60] if msg_text else '❌ تنظیم نشده'}...\n\n"
                            f"🕐 **ارسال زمان‌بندی شده:** {sch_st}\n"
                            f"👥 **گروه:** {sch.get('group_id', '❌')[:20] if sch.get('group_id') else '❌'}\n"
                            f"🕐 **ساعت:** {sch.get('time', '00:00')}\n\n"
                            f"🎯 از دکمه‌های زیر استفاده کنید:",
                            kb_ads_management()
                        )
                        return
                    
                    elif button_id == "set_ads_text":
                        self.user_states[sender] = {"step": "waiting_ads_text"}
                        current = load_ads_config().get("message", "")
                        await reply_kb(msg,
                            f"📝 **تنظیم متن تبلیغ**\n\n"
                            f"📄 **متن فعلی:** {current[:100] if current else '❌ خالی'}{'...' if len(current) > 100 else ''}\n\n"
                            f"✍️ **متن جدید را وارد کنید:**\n"
                            f"💡 می‌تونید از ایموجی و قالب‌بندی استفاده کنید",
                            kb_back_to_ads()
                        )
                        return
                    
                    elif button_id == "set_ads_time":
                        self.user_states[sender] = {"step": "waiting_ads_time"}
                        current = load_ads_config().get("interval_minutes", 60)
                        await reply_kb(msg,
                            f"⏰ **تنظیم فاصله زمانی تبلیغات**\n\n"
                            f"🕐 **فاصله فعلی:** هر {current} دقیقه\n\n"
                            f"📝 **فاصله جدید را به دقیقه وارد کنید:**\n"
                            f"• حداقل: 1 دقیقه\n"
                            f"• حداکثر: 1440 دقیقه (24 ساعت)\n"
                            f"• پیشنهادی: 60 یا 120\n"
                            f"• مثال: 60",
                            kb_back_to_ads()
                        )
                        return
                    
                    elif button_id == "start_ads":
                        config = load_ads_config()
                        if not config.get("message"):
                            await reply_kb(msg,
                                "❌ **ابتدا متن تبلیغ را تنظیم کنید!**\n\n"
                                "📝 از دکمه «تنظیم متن تبلیغ» استفاده کنید",
                                kb_ads_management()
                            )
                        elif not self.groups:
                            await reply_kb(msg,
                                "❌ **هیچ گروهی ثبت نشده!**\n\n"
                                "➕ ابتدا گروه اضافه کنید",
                                kb_ads_management()
                            )
                        else:
                            config["enabled"] = True
                            config["last_sent"] = None
                            save_ads_config(config)
                            await reply_kb(msg,
                                f"✅ **تبلیغات خودکار با موفقیت فعال شد!**\n\n"
                                f"⏰ **فاصله ارسال:** هر {config.get('interval_minutes', 60)} دقیقه\n"
                                f"👥 **گروه‌های هدف:** {len(self.groups)} گروه\n"
                                f"📢 **اولین ارسال:** به زودی انجام می‌شود\n\n"
                                f"💡 برای توقف، دکمه «توقف تبلیغات» را بزنید",
                                kb_ads_management()
                            )
                        return
                    
                    elif button_id == "stop_ads":
                        config = load_ads_config()
                        config["enabled"] = False
                        save_ads_config(config)
                        await reply_kb(msg,
                            "⏸️ **تبلیغات خودکار متوقف شد**\n\n"
                            "✅ تبلیغات دیگر به صورت خودکار ارسال نمی‌شود\n"
                            "💡 برای شروع مجدد، دکمه «شروع تبلیغات» را بزنید",
                            kb_ads_management()
                        )
                        return
                    
                    elif button_id == "send_ads_now":
                        config = load_ads_config()
                        message = config.get("message", "")
                        if not message:
                            await reply_kb(msg,
                                "❌ **ابتدا متن تبلیغ را تنظیم کنید!**",
                                kb_ads_management()
                            )
                        elif not self.groups:
                            await reply_kb(msg,
                                "❌ **هیچ گروهی ثبت نشده!**",
                                kb_ads_management()
                            )
                        else:
                            await msg.reply(f"⏳ **در حال ارسال فوری تبلیغ به {len(self.groups)} گروه...**")
                            s, f = 0, 0
                            for g in self.groups:
                                try:
                                    await bot.send_message(g, message)
                                    s += 1
                                    await asyncio.sleep(0.3)
                                except:
                                    f += 1
                            self.group_stats["total_messages"] += s
                            self.group_stats["last_broadcast"] = {
                                "text": message[:50], "time": datetime.now().strftime('%H:%M:%S'),
                                "success": s, "failed": f, "type": "instant_ads"
                            }
                            self.save_all_data()
                            await reply_kb(msg,
                                f"✅ **ارسال فوری انجام شد!**\n\n"
                                f"📊 **نتیجه:**\n"
                                f"• ✅ موفق: {s} گروه\n"
                                f"• ❌ ناموفق: {f} گروه",
                                kb_ads_management()
                            )
                        return
                    
                    elif button_id == "ads_status":
                        config = load_ads_config()
                        status = "✅ فعال" if config.get("enabled") else "⏸️ غیرفعال"
                        await reply_kb(msg,
                            f"📊 **وضعیت کامل تبلیغات**\n\n"
                            f"⚙️ **وضعیت:** {status}\n"
                            f"⏰ **فاصله:** هر {config.get('interval_minutes', 60)} دقیقه\n"
                            f"👥 **گروه‌های هدف:** {len(self.groups)}\n"
                            f"📝 **متن:** {config.get('message', '---')[:120]}{'...' if len(config.get('message', '')) > 120 else ''}\n"
                            f"🕐 **آخرین ارسال:** {config.get('last_sent', 'هنوز ارسال نشده')}",
                            kb_ads_management()
                        )
                        return
                    
                    # ===== ارسال زمان‌بندی شده =====
                    elif button_id == "scheduled_message":
                        sch = load_scheduled_message()
                        st = "✅ فعال" if sch.get("enabled") else "⏸️ غیرفعال"
                        await reply_kb(msg,
                            f"🕐 **ارسال زمان‌بندی شده**\n\n"
                            f"⚙️ **وضعیت:** {st}\n"
                            f"👥 **گروه مقصد:** {sch.get('group_id', '❌ تنظیم نشده')[:25] if sch.get('group_id') else '❌ تنظیم نشده'}\n"
                            f"🕐 **ساعت ارسال:** {sch.get('time', '00:00')}\n"
                            f"📝 **متن:** {sch.get('message', '❌')[:60]}...\n"
                            f"🕐 **آخرین ارسال:** {sch.get('last_sent', '---')}\n\n"
                            f"🎯 **تنظیمات:**",
                            kb_scheduled_message()
                        )
                        return
                    
                    elif button_id == "set_sch_group":
                        self.user_states[sender] = {"step": "waiting_sch_group"}
                        await reply_kb(msg,
                            "👥 **تنظیم گوید گروه مقصد**\n\n"
                            "📝 **گوید (Chat ID) گروه را وارد کنید:**\n\n"
                            "💡 پیام زمان‌بندی شده فقط به این گروه ارسال می‌شود",
                            kb_back_to_ads()
                        )
                        return
                    
                    elif button_id == "set_sch_text":
                        self.user_states[sender] = {"step": "waiting_sch_text"}
                        await reply_kb(msg,
                            "📝 **تنظیم متن پیام**\n\n"
                            "✍️ **متن پیام زمان‌بندی شده را وارد کنید:**\n\n"
                            "💡 این متن هر روز در ساعت مقرر ارسال می‌شود",
                            kb_back_to_ads()
                        )
                        return
                    
                    elif button_id == "set_sch_time":
                        self.user_states[sender] = {"step": "waiting_sch_time"}
                        await reply_kb(msg,
                            "🕐 **تنظیم ساعت ارسال**\n\n"
                            "📝 **ساعت را به فرمت 24 ساعته وارد کنید:**\n\n"
                            "• مثال: 00:00 (نیمه شب)\n"
                            "• مثال: 08:30 (صبح)\n"
                            "• مثال: 23:59 (شب)\n\n"
                            "💡 هر روز در این ساعت پیام ارسال می‌شود",
                            kb_back_to_ads()
                        )
                        return
                    
                    elif button_id == "start_sch":
                        sch = load_scheduled_message()
                        if not sch.get("group_id"):
                            await reply_kb(msg,
                                "❌ **ابتدا گوید گروه را تنظیم کنید!**\n\n"
                                "👥 از دکمه «تنظیم گوید گروه» استفاده کنید",
                                kb_scheduled_message()
                            )
                        elif not sch.get("message"):
                            await reply_kb(msg,
                                "❌ **ابتدا متن پیام را تنظیم کنید!**\n\n"
                                "📝 از دکمه «تنظیم متن پیام» استفاده کنید",
                                kb_scheduled_message()
                            )
                        else:
                            sch["enabled"] = True
                            sch["last_sent"] = None
                            save_scheduled_message(sch)
                            await reply_kb(msg,
                                f"✅ **ارسال زمان‌بندی شده فعال شد!**\n\n"
                                f"👥 **گروه:** `{sch['group_id'][:15]}...`\n"
                                f"🕐 **ساعت:** {sch.get('time', '00:00')}\n"
                                f"📝 **متن:** {sch['message'][:50]}...\n\n"
                                f"📅 هر روز در ساعت مقرر پیام ارسال می‌شود",
                                kb_scheduled_message()
                            )
                        return
                    
                    elif button_id == "stop_sch":
                        sch = load_scheduled_message()
                        sch["enabled"] = False
                        save_scheduled_message(sch)
                        await reply_kb(msg,
                            "⏸️ **ارسال زمان‌بندی شده متوقف شد**\n\n"
                            "📅 دیگر پیامی به صورت خودکار ارسال نمی‌شود\n"
                            "💡 برای فعال‌سازی دوباره کلیک کنید",
                            kb_scheduled_message()
                        )
                        return
                    
                    elif button_id == "sch_status":
                        sch = load_scheduled_message()
                        st = "✅ فعال" if sch.get("enabled") else "⏸️ غیرفعال"
                        await reply_kb(msg,
                            f"📊 **وضعیت ارسال زمان‌بندی شده**\n\n"
                            f"⚙️ **وضعیت:** {st}\n"
                            f"👥 **گروه:** {sch.get('group_id', '---')[:25]}\n"
                            f"🕐 **ساعت:** {sch.get('time', '---')}\n"
                            f"📝 **متن:** {sch.get('message', '---')[:80]}...\n"
                            f"🕐 **آخرین ارسال:** {sch.get('last_sent', '---')}",
                            kb_scheduled_message()
                        )
                        return
                    
                    # ===== بخش فونت =====
                    elif button_id == "font_section":
                        await reply_kb(msg,
                            "✨ **بخش فونت**\n\n"
                            "یکی از شعبه‌ها را برای تبدیل فونت انتخاب کنید:\n\n"
                            "📋 **قالب‌های نهایی:**\n"
                            "• شعبه یک: ✦اسم‹🌙›․↵\n"
                            "• شعبه دو: ✦اسم‹⭐›․↵\n\n"
                            "💡 بعد از انتخاب شعبه، اسم انگلیسی را وارد کنید",
                            kb_font_section()
                        )
                        return
                    
                    # ===== مدیریت ادمین‌ها =====
                    elif button_id == "admin_management":
                        admins = self.font_admins.get("admins", [])
                        await reply_kb(msg,
                            f"👥 **مدیریت ادمین‌های فونت**\n\n"
                            f"👑 **سازنده اول:** `{CREATORS[0][:15]}...`\n"
                            f"👑 **سازنده دوم:** `{CREATORS[1][:15]}...`\n"
                            f"👨‍💼 **ادمین‌های فونت:** {len(admins)}\n\n"
                            f"🎯 از دکمه‌های زیر برای مدیریت استفاده کنید:\n"
                            f"• ➕ افزودن ادمین جدید\n"
                            f"• ➖ حذف ادمین\n"
                            f"• 📋 مشاهده لیست کامل",
                            kb_admin_management()
                        )
                        return
                    
                    elif button_id == "add_admin":
                        self.user_states[sender] = {"step": "waiting_add_admin"}
                        await reply_kb(msg,
                            "➕ **افزودن ادمین فونت جدید**\n\n"
                            "📝 **آیدی کاربر را وارد کنید:**\n\n"
                            "💡 **راهنما:**\n"
                            "• کاربر باید آیدی خود را از دکمه «🆔 شناسه من» دریافت کند\n"
                            "• ادمین فونت می‌تواند از بخش فونت استفاده کند\n"
                            "🔙 برای بازگشت دکمه بازگشت را بزنید",
                            kb_back_only()
                        )
                        return
                    
                    elif button_id == "remove_admin":
                        admins = self.font_admins.get("admins", [])
                        if admins:
                            txt = f"➖ **حذف ادمین فونت**\n\n"
                            txt += f"📋 **ادمین‌های فعلی ({len(admins)}):**\n"
                            for i, a in enumerate(admins, 1):
                                txt += f"{i}. `{a}`\n"
                            txt += f"\n📝 **آیدی ادمین مورد نظر را برای حذف وارد کنید:**"
                            self.user_states[sender] = {"step": "waiting_remove_admin"}
                            await reply_kb(msg, txt, kb_back_only())
                        else:
                            await reply_kb(msg,
                                "📭 **هیچ ادمینی برای حذف وجود ندارد**\n\n"
                                "➕ می‌توانید از دکمه «افزودن ادمین» استفاده کنید",
                                kb_admin_management()
                            )
                        return
                    
                    elif button_id == "admin_list":
                        admins = self.font_admins.get("admins", [])
                        txt = f"📋 **لیست کامل ادمین‌های فونت**\n\n"
                        txt += f"👑 **سازندگان (دسترسی کامل):**\n"
                        txt += f"• `{CREATORS[0][:15]}...`\n"
                        txt += f"• `{CREATORS[1][:15]}...`\n\n"
                        txt += f"👨‍💼 **ادمین‌های فونت ({len(admins)}):**\n"
                        txt += "\n".join([f"• `{a}`" for a in admins]) if admins else "• لیست خالی\n\n💡 با دکمه «➕ افزودن» ادمین جدید اضافه کنید"
                        await reply_kb(msg, txt, kb_admin_management())
                        return
                    
                    # ===== راهنما =====
                    elif button_id == "creator_help":
                        await reply_kb(msg,
                            "📚 **راهنمای کامل پنل مدیریت**\n\n"
                            "📢 **ارسال پیام:** ارسال متن به همه گروه‌ها با آمار کامل\n"
                            "📁 **ارسال فایل:** ارسال عکس/ویدیو/سند به گروه‌ها یا کاربر\n"
                            "📋 **لیست گروه‌ها:** مشاهده گروه‌های ثبت شده\n"
                            "👤 **لیست کاربران:** مشاهده کاربران وارد شده\n"
                            "➕ **افزودن گروه:** اضافه کردن گروه جدید با گوید\n"
                            "➖ **حذف گروه:** حذف گروه از لیست\n"
                            "📊 **آمار:** مشاهده آمار کامل ربات\n"
                            "📣 **تبلیغات:** مدیریت تبلیغات خودکار و زمان‌بندی\n"
                            "🕐 **زمان‌بندی:** ارسال پیام در ساعت مشخص به گروه خاص\n"
                            "✨ **فونت:** تبدیل متن به فونت بولد\n"
                            "👥 **ادمین‌ها:** مدیریت ادمین‌های فونت\n"
                            "🟢/🔴 **تغییر وضعیت:** فعال/غیرفعال کردن ربات\n\n"
                            "💡 در هر بخش دکمه 🔙 بازگشت وجود دارد",
                            kb_creator_main(self.bot_active)
                        )
                        return
                    
                    # ===== بازگشت =====
                    elif button_id == "back_to_main":
                        if sender in self.user_states:
                            del self.user_states[sender]
                        await reply_kb(msg,
                            "🔙 **بازگشت به منوی اصلی**\n\n"
                            "از دکمه‌های زیر استفاده کنید:",
                            kb_creator_main(self.bot_active)
                        )
                        return
                    
                    elif button_id == "back_to_ads":
                        if sender in self.user_states:
                            del self.user_states[sender]
                        await reply_kb(msg,
                            "🔙 **بازگشت به مدیریت تبلیغات**",
                            kb_ads_management()
                        )
                        return
                
                # ---- ادمین فونت (نه سازنده) ----
                if is_font_admin(sender) and not is_creator(sender):
                    if button_id == "back_to_main":
                        if sender in self.user_states:
                            del self.user_states[sender]
                        await reply_kb(msg,
                            "🔙 **بازگشت**\n\nاز دکمه‌ها استفاده کنید:",
                            kb_font_admin()
                        )
                        return

            # ===== /start =====
            if text == "/start":
                if is_creator(sender):
                    await reply_kb(msg,
                        f"👑 **پنل مدیریت سوپرربات**\n\n"
                        f"🤖 **وضعیت ربات:** {'🟢 فعال' if self.bot_active else '🔴 غیرفعال'}\n"
                        f"🆔 **شناسه شما:** `{sender}`\n"
                        f"👥 **گروه‌ها:** {len(self.groups)}\n"
                        f"👤 **کاربران:** {len(self.user_notified)}\n"
                        f"👨‍💼 **ادمین‌ها:** {len(self.font_admins.get('admins', []))}\n"
                        f"📁 **فایل‌های منتظر:** {len(self.pending_files)}\n"
                        f"⏰ **زمان:** {datetime.now().strftime('%H:%M:%S')}\n\n"
                        f"🎯 از دکمه‌های زیر برای مدیریت ربات استفاده کنید:",
                        kb_creator_main(self.bot_active)
                    )
                elif is_font_admin(sender):
                    await reply_kb(msg,
                        f"👨‍💼 **ربات تبدیل فونت**\n\n"
                        f"🆔 **شناسه شما:** `{sender}`\n\n"
                        f"🎯 **یکی از شعبه‌ها را انتخاب کنید:**\n"
                        f"• 🌙 شعبه یک: ✦اسم‹🌙›․↵\n"
                        f"• ⭐ شعبه دو: ✦اسم‹⭐›․↵\n\n"
                        f"از دکمه‌های زیر استفاده کنید:",
                        kb_font_admin()
                    )
                return

            # ===== پیام ناشناخته =====
            if is_font_admin(sender) and not is_creator(sender) and text:
                await reply_kb(msg,
                    "👆 **لطفاً از دکمه‌های کیبورد استفاده کنید**\n\n"
                    "برای راهنمایی بیشتر دکمه «📚 راهنما» را بزنید",
                    kb_font_admin()
                )
                return
            
            if is_creator(sender) and text:
                await reply_kb(msg,
                    "👆 **لطفاً از دکمه‌های کیبورد استفاده کنید**\n\n"
                    "یا /start را برای نمایش منوی اصلی بزنید",
                    kb_creator_main(self.bot_active)
                )

        async def run_bot():
            ads_task = asyncio.create_task(self.auto_ads_loop())
            sch_task = asyncio.create_task(self.scheduled_message_loop())
            try:
                await self.bot.run()
            finally:
                ads_task.cancel()
                sch_task.cancel()

        try:
            asyncio.run(run_bot())
        except KeyboardInterrupt:
            print("\n🛑 ربات متوقف شد")
            self.save_all_data()
        except Exception as e:
            print(f"❌ خطا: {e}")
            self.save_all_data()

if __name__ == "__main__":
    SuperBot().run()