from balethon import Client
from balethon.objects import InlineKeyboard, InlineKeyboardButton
import json
import os
import asyncio
import time
import random

TOKEN = "635020900:z6XRHPfpKnaZUr2LKfMr-GxHX_b_1yRhC2E"
bot = Client(TOKEN)

DATA_FILE = "data.json"
HISTORY_FILE = "history.json"

tag_cooldown = {}
muted_users = {}
admin_panel_message_id = {}
banned_users = {}
spam_tracker = {}
last_error_message_time = {}
admin_panel_state = {}
admin_panel_data = {}
admin_permissions = {}
locks = {}
fun_responses = {}
jokes = []
facts = []
used_jokes = []
used_facts = []

COOLDOWN_SECONDS = 120
SPAM_LIMIT = 5
SPAM_WINDOW = 10
ERROR_COOLDOWN = 300

def load_data():
    if os.path.exists(DATA_FILE):
        try:
            with open(DATA_FILE, "r", encoding="utf-8") as f:
                return json.load(f)
        except:
            return {}
    return {}

def save_data():
    with open(DATA_FILE, "w", encoding="utf-8") as f:
        json.dump({
            "group_admins": group_admins,
            "link_locks": link_locks,
            "collected_members": collected_members,
            "templates": templates,
            "muted_users": muted_users,
            "banned_users": banned_users,
            "admin_permissions": admin_permissions,
            "locks": locks,
            "fun_responses": fun_responses,
            "jokes": jokes,
            "facts": facts,
            "used_jokes": used_jokes,
            "used_facts": used_facts
        }, f, ensure_ascii=False, indent=2)

def load_history():
    if os.path.exists(HISTORY_FILE):
        try:
            with open(HISTORY_FILE, "r", encoding="utf-8") as f:
                return json.load(f)
        except:
            return {}
    return {}

def save_history():
    with open(HISTORY_FILE, "w", encoding="utf-8") as f:
        json.dump(message_history, f, ensure_ascii=False, indent=2)

data = load_data()
group_admins = data.get("group_admins", {})
link_locks = data.get("link_locks", {})
collected_members = data.get("collected_members", {})
templates = data.get("templates", {})
muted_users = data.get("muted_users", {})
banned_users = data.get("banned_users", {})
admin_permissions = data.get("admin_permissions", {})
locks = data.get("locks", {})
fun_responses = data.get("fun_responses", {})
jokes = data.get("jokes", [])
facts = data.get("facts", [])
used_jokes = data.get("used_jokes", [])
used_facts = data.get("used_facts", [])
message_history = load_history()

def migrate_data():
    global collected_members
    for chat_id, members in list(collected_members.items()):
        if isinstance(members, list):
            collected_members[chat_id] = {str(m): str(m) for m in members}
    save_data()

migrate_data()

print("💀 DeadBale ربات شروع به کار کرد!")

def is_admin(chat_id, user_id):
    return group_admins.get(str(chat_id)) == str(user_id)

def is_owner(chat_id, user_id):
    return group_admins.get(str(chat_id)) == str(user_id)

def has_permission(chat_id, user_id, perm):
    return admin_permissions.get(str(chat_id), {}).get(str(user_id), {}).get(perm, False)

def contains_link(text):
    return "http://" in text.lower() or "https://" in text.lower() or "www." in text.lower()

def is_muted(chat_id, user_id):
    chat_id_str = str(chat_id)
    user_id_str = str(user_id)
    if chat_id_str in muted_users and user_id_str in muted_users[chat_id_str]:
        if time.time() < muted_users[chat_id_str][user_id_str]:
            return True
        else:
            del muted_users[chat_id_str][user_id_str]
            save_data()
    return False

def is_banned(chat_id, user_id):
    return banned_users.get(str(chat_id), {}).get(str(user_id), False)

def check_spam(chat_id, user_id):
    chat_id_str = str(chat_id)
    user_id_str = str(user_id)
    current_time = time.time()
    
    if chat_id_str not in spam_tracker:
        spam_tracker[chat_id_str] = {}
    if user_id_str not in spam_tracker[chat_id_str]:
        spam_tracker[chat_id_str][user_id_str] = []
    
    spam_tracker[chat_id_str][user_id_str].append(current_time)
    spam_tracker[chat_id_str][user_id_str] = [
        t for t in spam_tracker[chat_id_str][user_id_str]
        if current_time - t < SPAM_WINDOW
    ]
    
    if len(spam_tracker[chat_id_str][user_id_str]) > SPAM_LIMIT:
        if chat_id_str not in banned_users:
            banned_users[chat_id_str] = {}
        banned_users[chat_id_str][user_id_str] = True
        save_data()
        return True
    return False

def can_send_error_message(chat_id, user_id):
    key = f"{chat_id}_{user_id}"
    current_time = time.time()
    if key in last_error_message_time:
        if current_time - last_error_message_time[key] < ERROR_COOLDOWN:
            return False
    last_error_message_time[key] = current_time
    return True

def get_username(chat_id, user_id):
    chat_data = collected_members.get(chat_id, {})
    if user_id in chat_data:
        return chat_data[user_id]
    for uid, name in chat_data.items():
        if str(uid) == str(user_id):
            return name
    return user_id

async def send_and_save(chat_id, text, **kwargs):
    msg = await bot.send_message(chat_id, text, **kwargs)
    chat_id_str = str(chat_id)
    if chat_id_str not in message_history:
        message_history[chat_id_str] = []
    message_history[chat_id_str].append({"id": msg.id, "text": text, "sender": "bot"})
    if len(message_history[chat_id_str]) > 200:
        message_history[chat_id_str].pop(0)
    save_history()
    return msg

async def fun_response(chat_id, raw_text):
    if chat_id not in fun_responses:
        return None
    for item in fun_responses[chat_id]:
        if item["trigger"].lower() in raw_text.lower():
            return item["response"]
    default_responses = [
        "🤣 آها! تو هم اومدی اذیت کنی؟",
        "😏 من از این حرفا زیاد دیدم!",
        "😂 بخند که دنیا بهت می‌خنده!",
        "😎 من رباتم، ولی تو آدمی؟ شک دارم!",
        "🤔 این حرفت رو باید جدی بگیرم یا بخندم؟",
        "🔥 بیا پایین، من حاضرم!",
        "💀 تو فکر کردی می‌تونی منو گول بزنی؟",
        "😆 بابا تو که دیوونه‌ای!"
    ]
    if "ساکت" in raw_text or "خفه" in raw_text:
        return "🤫 خودت ساکت شو! من حرف دارم!"
    if "احمق" in raw_text or "خنگ" in raw_text:
        return "🧠 تو که فکر می‌کنی زرنگی؟ بیا ببینم!"
    if "گربه" in raw_text:
        return "🐱 میو؟ منظورت منم؟!"
    return random.choice(default_responses)

def get_joke():
    global jokes, used_jokes
    available = [j for j in jokes if j not in used_jokes]
    if not available:
        used_jokes = []
        available = jokes
    joke = random.choice(available) if available else "جوکی پیدا نشد! 😅"
    used_jokes.append(joke)
    save_data()
    return joke

def get_fact():
    global facts, used_facts
    available = [f for f in facts if f not in used_facts]
    if not available:
        used_facts = []
        available = facts
    fact = random.choice(available) if available else "فکتی پیدا نشد! 😅"
    used_facts.append(fact)
    save_data()
    return fact

@bot.on_message()
async def handle(message):
    if not message.text:
        return

    chat_id = str(message.chat.id)
    user_id = str(message.author.id)
    chat_type = message.chat.type
    username = message.author.username or user_id
    raw_text = message.text.strip()
    cmd = raw_text.split()[0].split('@')[0] if raw_text else ""

    if chat_type == "group":
        if is_banned(chat_id, user_id):
            try:
                await bot.delete_message(int(chat_id), message.id)
            except:
                pass
            return
        if is_muted(chat_id, user_id):
            try:
                await bot.delete_message(int(chat_id), message.id)
            except:
                pass
            return

    if chat_id not in message_history:
        message_history[chat_id] = []
    if chat_type == "group":
        is_system = False
        if hasattr(message, 'new_chat_members') and message.new_chat_members:
            is_system = True
        if hasattr(message, 'left_chat_member') and message.left_chat_member:
            is_system = True
        if not is_system:
            message_history[chat_id].append({"id": message.id, "text": raw_text, "sender": user_id})
            if len(message_history[chat_id]) > 200:
                message_history[chat_id].pop(0)
            save_history()

    if hasattr(message, 'new_chat_members') and message.new_chat_members:
        for member in message.new_chat_members:
            if not member.is_bot:
                if chat_id not in collected_members:
                    collected_members[chat_id] = {}
                collected_members[chat_id][str(member.id)] = member.username or str(member.id)
                save_data()
                await send_and_save(int(chat_id), f"🎉 خوش آمدید @{member.username or member.id}!")
        return

    if hasattr(message, 'left_chat_member') and message.left_chat_member:
        left_id = str(message.left_chat_member.id)
        if chat_id in collected_members and left_id in collected_members[chat_id]:
            del collected_members[chat_id][left_id]
            save_data()
        return

    if chat_type == "group":
        if chat_id not in collected_members:
            collected_members[chat_id] = {}
        if user_id not in collected_members[chat_id]:
            collected_members[chat_id][user_id] = username
            save_data()

    if chat_type == "group" and not raw_text.startswith("/") and not raw_text.startswith("گربه") and not raw_text.startswith("حذف") and not raw_text.startswith("چسب") and not raw_text.startswith("رفع"):
        if locks.get(chat_id, {}).get("chatbot", True):
            response = await fun_response(chat_id, raw_text)
            if response:
                await send_and_save(int(chat_id), response)
                return

    if raw_text == "جوک":
        await send_and_save(int(chat_id), f"😂 **جوک لحظه:**\n{get_joke()}")
        return
    if raw_text == "فکت":
        await send_and_save(int(chat_id), f"📌 **فکت جالب:**\n{get_fact()}")
        return

    if hasattr(message, 'reply_to_message') and message.reply_to_message:
        replied_msg_id = message.reply_to_message.id
        replied_user_id = str(message.reply_to_message.author.id)
        replied_username = message.reply_to_message.author.username or replied_user_id

        # ===== سیک (اخراج کاربر از گروه) =====
        if raw_text == "سیک":
            if chat_type != "group":
                await send_and_save(int(chat_id), "⚠️ این دستور فقط در گروه قابل استفاده است.")
                return
            if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "ban"):
                await send_and_save(int(chat_id), "❌ فقط ادمین یا مالک گروه می‌تواند از این دستور استفاده کند.")
                return
            try:
                await bot.ban_chat_member(int(chat_id), int(replied_user_id))
                try:
                    await bot.delete_message(int(chat_id), replied_msg_id)
                except:
                    pass
                try:
                    await bot.delete_message(int(chat_id), message.id)
                except:
                    pass
                await send_and_save(int(chat_id), f"🚫 کاربر @{replied_username} با موفقیت از گروه اخراج شد!")
                if chat_id not in banned_users:
                    banned_users[chat_id] = {}
                banned_users[chat_id][replied_user_id] = True
                save_data()
            except Exception as e:
                await send_and_save(int(chat_id), f"❌ خطا در اخراج کاربر: {e}")
            return

        # ===== پین =====
        if raw_text == "پین":
            if chat_type != "group":
                await send_and_save(int(chat_id), "⚠️ این دستور فقط در گروه قابل استفاده است.")
                return
            if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "pin"):
                await send_and_save(int(chat_id), "❌ شما دسترسی پین کردن ندارید.")
                return
            try:
                await bot.pin_chat_message(int(chat_id), replied_msg_id)
                await send_and_save(int(chat_id), "📌 پیام با موفقیت پین شد.")
            except Exception as e:
                await send_and_save(int(chat_id), f"❌ خطا در پین کردن: {e}")
            return

        # ===== حذف پین =====
        if raw_text == "حذف پین":
            if chat_type != "group":
                await send_and_save(int(chat_id), "⚠️ این دستور فقط در گروه قابل استفاده است.")
                return
            if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "pin"):
                await send_and_save(int(chat_id), "❌ شما دسترسی حذف پین ندارید.")
                return
            try:
                await bot.unpin_all_chat_messages(int(chat_id))
                await send_and_save(int(chat_id), "🗑️ همه پین‌های گروه برداشته شد.")
            except Exception as e:
                await send_and_save(int(chat_id), f"❌ خطا: {e}")
            return

        # ===== حذف =====
        if raw_text == "حذف":
            if chat_type != "group":
                await send_and_save(int(chat_id), "⚠️ این دستور فقط در گروه قابل استفاده است.")
                return
            if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "delete"):
                await send_and_save(int(chat_id), "❌ شما دسترسی حذف ندارید.")
                return
            try:
                await bot.delete_message(int(chat_id), replied_msg_id)
                message_history[chat_id] = [msg for msg in message_history[chat_id] if msg["id"] != replied_msg_id]
                save_history()
            except:
                pass
            try:
                await bot.delete_message(int(chat_id), message.id)
                message_history[chat_id] = [msg for msg in message_history[chat_id] if msg["id"] != message.id]
                save_history()
            except:
                pass
            return

        # ===== چسب گربه ای =====
        if raw_text == "چسب گربه ای":
            if chat_type != "group":
                await send_and_save(int(chat_id), "⚠️ این دستور فقط در گروه قابل استفاده است.")
                return
            if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "ban"):
                await send_and_save(int(chat_id), "❌ شما دسترسی بن کردن ندارید.")
                return
            if chat_id not in banned_users:
                banned_users[chat_id] = {}
            banned_users[chat_id][replied_user_id] = True
            save_data()
            await send_and_save(int(chat_id), f"🚫 کاربر @{replied_username} با موفقیت بن شد!")
            return

        # ===== رفع تحریم =====
        if raw_text == "رفع تحریم":
            if chat_type != "group":
                await send_and_save(int(chat_id), "⚠️ این دستور فقط در گروه قابل استفاده است.")
                return
            if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "ban"):
                await send_and_save(int(chat_id), "❌ شما دسترسی رفع تحریم ندارید.")
                return
            removed_banned = False
            removed_muted = False
            if chat_id in banned_users and replied_user_id in banned_users[chat_id]:
                del banned_users[chat_id][replied_user_id]
                removed_banned = True
            if chat_id in muted_users and replied_user_id in muted_users[chat_id]:
                del muted_users[chat_id][replied_user_id]
                removed_muted = True
            if removed_banned or removed_muted:
                save_data()
                msg = "✅ تحریم کاربر @{} برداشته شد.".format(replied_username)
                if removed_banned and removed_muted:
                    msg = "✅ بن و سکوت کاربر @{} برداشته شد.".format(replied_username)
                elif removed_banned:
                    msg = "✅ بن کاربر @{} برداشته شد.".format(replied_username)
                elif removed_muted:
                    msg = "✅ سکوت کاربر @{} برداشته شد.".format(replied_username)
                await send_and_save(int(chat_id), msg)
            else:
                await send_and_save(int(chat_id), f"⚠️ کاربر @{replied_username} در لیست بن یا سکوت نیست.")
            return

        # ===== گربه خشن =====
        if raw_text == "گربه خشن":
            if chat_type != "group":
                await send_and_save(int(chat_id), "⚠️ این دستور فقط در گروه قابل استفاده است.")
                return
            if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "ban"):
                await send_and_save(int(chat_id), "❌ شما دسترسی اخراج ندارید.")
                return
            try:
                await bot.ban_chat_member(int(chat_id), int(replied_user_id))
                await send_and_save(int(chat_id), f"🚫 کاربر @{replied_username} از گروه اخراج شد!")
                if chat_id not in banned_users:
                    banned_users[chat_id] = {}
                banned_users[chat_id][replied_user_id] = True
                save_data()
            except Exception as e:
                await send_and_save(int(chat_id), f"❌ خطا در اخراج کاربر: {e}")
            return

        # ===== چسب رازی =====
        if raw_text.startswith("چسب رازی "):
            if chat_type != "group":
                await send_and_save(int(chat_id), "⚠️ این دستور فقط در گروه قابل استفاده است.")
                return
            if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "ban"):
                await send_and_save(int(chat_id), "❌ شما دسترسی سکوت ندارید.")
                return
            number_part = raw_text[len("چسب رازی "):].strip()
            try:
                minutes = int(number_part)
                if minutes > 1440:
                    await send_and_save(int(chat_id), "⚠️ حداکثر زمان سکوت ۱۴۴۰ دقیقه (۲۴ ساعت) است.")
                    return
                if minutes < 1:
                    await send_and_save(int(chat_id), "⚠️ زمان سکوت باید حداقل ۱ دقیقه باشد.")
                    return
            except ValueError:
                await send_and_save(int(chat_id), "⚠️ لطفاً یک عدد معتبر وارد کنید. مثال: `چسب رازی 30`")
                return
            until = time.time() + (minutes * 60)
            if chat_id not in muted_users:
                muted_users[chat_id] = {}
            muted_users[chat_id][replied_user_id] = until
            save_data()
            await send_and_save(int(chat_id), f"🔇 کاربر @{replied_username} به مدت {minutes} دقیقه سکوت شد.")
            return

        # ===== مدیر =====
        if raw_text == "مدیر":
            if chat_type != "group":
                await send_and_save(int(chat_id), "⚠️ این دستور فقط در گروه قابل استفاده است.")
                return
            if not is_owner(chat_id, user_id):
                await send_and_save(int(chat_id), "❌ فقط مالک گروه می‌تواند مدیر اضافه کند.")
                return
            if chat_id not in admin_permissions:
                admin_permissions[chat_id] = {}
            admin_permissions[chat_id][replied_user_id] = {
                "panel": False,
                "delete": False,
                "pin": False,
                "ban": False
            }
            save_data()
            await send_and_save(int(chat_id), f"👤 کاربر @{replied_username} به لیست مدیران اضافه شد.")
            return

        # ===== حذف مدیر =====
        if raw_text == "حذف مدیر":
            if chat_type != "group":
                await send_and_save(int(chat_id), "⚠️ این دستور فقط در گروه قابل استفاده است.")
                return
            if not is_owner(chat_id, user_id):
                await send_and_save(int(chat_id), "❌ فقط مالک گروه می‌تواند مدیر حذف کند.")
                return
            if chat_id in admin_permissions and replied_user_id in admin_permissions[chat_id]:
                del admin_permissions[chat_id][replied_user_id]
                save_data()
                await send_and_save(int(chat_id), f"👤 کاربر @{replied_username} از لیست مدیران حذف شد.")
            else:
                await send_and_save(int(chat_id), f"⚠️ کاربر @{replied_username} در لیست مدیران نیست.")
            return

    if chat_type == "group" and not is_admin(chat_id, user_id):
        if check_spam(chat_id, user_id):
            await send_and_save(int(chat_id), f"🚫 @{username} به دلیل اسپم بن شد!")
            try:
                await bot.ban_chat_member(int(chat_id), int(user_id))
                await bot.delete_message(int(chat_id), message.id)
            except:
                pass
            return

    if raw_text == "گربه پنل بسته":
        if chat_type != "group":
            await send_and_save(int(chat_id), "⚠️ این دستور فقط در گروه قابل استفاده است.")
            return
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "panel"):
            await send_and_save(int(chat_id), "❌ شما دسترسی بستن پنل ندارید.")
            return
        
        if chat_id in admin_panel_message_id:
            try:
                await bot.delete_message(int(chat_id), admin_panel_message_id[chat_id])
            except:
                pass
            admin_panel_message_id.pop(chat_id, None)
        
        closed_count = 0
        for cid in list(admin_panel_state.keys()):
            if admin_panel_state.get(cid) == user_id:
                admin_panel_state.pop(cid, None)
                admin_panel_data.pop(cid, None)
                closed_count += 1
        if closed_count > 0:
            await send_and_save(int(chat_id), "🐱 پنل (ها) با موفقیت بسته شدن")
        else:
            await send_and_save(int(chat_id), "⚠️ شما هیچ پنل بازی ندارید.")
        return

    if chat_id in admin_panel_state and admin_panel_state.get(chat_id) == user_id and raw_text.isdigit():
        if admin_panel_data.get(chat_id, {}).get("step", 0) == 1:
            choice = int(raw_text)
            items = admin_panel_data[chat_id].get("list", [])
            if choice == 0:
                admin_panel_data[chat_id] = {"step": 0, "list": []}
                await send_and_save(int(chat_id), "✅ از منوی تحریم‌ها خارج شدید.")
                admin_panel_state.pop(chat_id, None)
                admin_panel_data.pop(chat_id, None)
                return
            if 1 <= choice <= len(items):
                uid = items[choice-1][0]
                name = get_username(chat_id, uid)
                removed_banned = False
                removed_muted = False
                if chat_id in banned_users and uid in banned_users[chat_id]:
                    del banned_users[chat_id][uid]
                    removed_banned = True
                if chat_id in muted_users and uid in muted_users[chat_id]:
                    del muted_users[chat_id][uid]
                    removed_muted = True
                if removed_banned or removed_muted:
                    save_data()
                    msg = f"✅ تحریم کاربر {name} برداشته شد."
                    if removed_banned and removed_muted:
                        msg = f"✅ بن و سکوت کاربر {name} برداشته شد."
                    elif removed_banned:
                        msg = f"✅ بن کاربر {name} برداشته شد."
                    elif removed_muted:
                        msg = f"✅ سکوت کاربر {name} برداشته شد."
                    keyboard = InlineKeyboard(
                        [("🔙 برگشت به پنل", "admin_back_from_ban")]
                    )
                    msg_obj = await bot.send_message(int(chat_id), msg, reply_markup=keyboard)
                    admin_panel_message_id[chat_id] = msg_obj.id
                else:
                    await send_and_save(int(chat_id), f"⚠️ کاربر {name} در لیست تحریم‌ها وجود ندارد.")
                
                banned_list = banned_users.get(chat_id, {})
                muted_list = muted_users.get(chat_id, {})
                all_restricted = {}
                for uid in banned_list:
                    all_restricted[uid] = {"type": "🚫 بن", "id": uid}
                for uid in muted_list:
                    if uid not in all_restricted:
                        all_restricted[uid] = {"type": "🔇 سکوت", "id": uid}
                    else:
                        all_restricted[uid]["type"] = "🚫 بن + 🔇 سکوت"
                if not all_restricted:
                    keyboard = InlineKeyboard(
                        [("🔙 برگشت به پنل", "admin_back")]
                    )
                    msg_obj = await bot.send_message(int(chat_id), "✅ هیچ کاربر تحریم‌شده‌ای در گروه وجود ندارد.", reply_markup=keyboard)
                    admin_panel_message_id[chat_id] = msg_obj.id
                    admin_panel_state.pop(chat_id, None)
                    admin_panel_data.pop(chat_id, None)
                    return
                list_text = "👥 **لیست کاربران تحریم‌شده (به‌روز):**\n\n"
                items = list(all_restricted.items())
                for idx, (uid, info) in enumerate(items, 1):
                    name = get_username(chat_id, uid)
                    list_text += f"{idx}. {info['type']} | {name} (@{uid})\n"
                list_text += f"\n➡️ برای آنبن کردن یک کاربر، شماره‌ی او را بفرستید.\n"
                list_text += f"➡️ یا برای خروج، عدد 0 را بفرستید."
                keyboard = InlineKeyboard(
                    [("🔙 برگشت به پنل", "admin_back_from_ban")]
                )
                msg_obj = await bot.send_message(int(chat_id), list_text, reply_markup=keyboard)
                admin_panel_message_id[chat_id] = msg_obj.id
                admin_panel_data[chat_id] = {"step": 1, "list": items}
                return
            else:
                if can_send_error_message(chat_id, user_id):
                    await send_and_save(int(chat_id), f"❌ شماره نامعتبر. لطفاً عدد ۱ تا {len(items)} یا ۰ را وارد کنید.")
                return

    if cmd == "/start" or raw_text == "گربه چاق":
        if chat_type == "group" and chat_id not in group_admins:
            group_admins[chat_id] = user_id
            save_data()
            await send_and_save(int(chat_id), "👑 شما مالک گروه شدید!")
        await send_and_save(int(chat_id),
            "👋 **به ربات DeadBale خوش آمدید!**\n\n"
            "🐱 من یه ربات باحال و خفنم!\n"
            "📋 **دستورات:**\n"
            "🔹 **مدیریت اعضا (فقط ادمین یا مالک):**\n"
            "   سیک (روی پیام ریپلای) → اخراج کاربر از گروه\n"
            "   چسب گربه ای (روی پیام ریپلای) → بن دائمی\n"
            "   رفع تحریم (روی پیام ریپلای) → رفع بن و سکوت\n"
            "   گربه خشن (روی پیام ریپلای) → اخراج از گروه\n"
            "   چسب رازی 30 (روی پیام ریپلای) → سکوت {عدد} دقیقه‌ای\n\n"
            "🔹 **مدیریت پیام (فقط ادمین):**\n"
            "   پین (روی پیام ریپلای) → پین کردن پیام\n"
            "   حذف پین (روی پیام ریپلای) → برداشتن همه پین‌ها\n"
            "   حذف (روی پیام ریپلای) → حذف پیام مقصد و پیام خودتان\n"
            "   حذف کل 30 → حذف ۳۰ پیام آخر\n"
            "   حذف بک‌تیک → حذف پیام‌های دارای علامت `\n\n"
            "🔹 **مدیران (فقط مالک):**\n"
            "   مدیر (روی پیام ریپلای) → اضافه کردن مدیر\n"
            "   حذف مدیر (روی پیام ریپلای) → حذف مدیر\n\n"
            "🔹 **پنل ادمین (فقط ادمین):**\n"
            "   گربه ادمین → نمایش پنل مدیریتی (دکمه‌ای)\n"
            "   گربه پنل → نمایش پنل مدیریتی (دکمه‌ای)\n"
            "   گربه پنل بسته → بستن پنل و حذف پیام آن\n\n"
            "🔹 **سرگرمی:**\n"
            "   جوک → یک جوک رندوم\n"
            "   فکت → یک فکت جالب\n\n"
            "🔹 **مدیریت الگو (فقط ادمین):**\n"
            "   حالت یادگیری متن تگ [متن]\n\n"
            "🔹 **مدیریت لیست تگ (فقط ادمین):**\n"
            "   اضافه کن @username - حذف کن @username - پاک کن لیست\n\n"
            "🔹 **ارسال تگ:**\n"
            "   تگ (ادمین: بدون محدودیت، سایرین: هر ۲ دقیقه)\n\n"
            "🔹 **دستور مخفی:**\n"
            "   گربه چاق → نمایش منو (مثل /start)"
        )
        return

    if raw_text == "گربه پنل":
        if chat_type != "group":
            await send_and_save(int(chat_id), "⚠️ این دستور فقط در گروه قابل استفاده است.")
            return
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "panel"):
            await send_and_save(int(chat_id), "❌ شما دسترسی به پنل ادمین ندارید.")
            return
        
        if chat_id in admin_panel_message_id:
            try:
                await bot.delete_message(int(chat_id), admin_panel_message_id[chat_id])
            except:
                pass
            admin_panel_message_id.pop(chat_id, None)
        
        keyboard = InlineKeyboard(
            [("📋 لیست تگ", "admin_list")],
            [("🗑️ پاک کن لیست", "admin_clear")],
            [("📊 آمار گروه", "admin_stats")],
            [("👥 مدیریت تحریم‌ها", "admin_ban_list")],
            [("🔧 مدیریت مدیران", "admin_manage_admins")],
            [("🔒 قفل‌ها", "admin_locks")],
            [("❌ بستن پنل", "admin_close")]
        )
        msg = await send_and_save(
            int(chat_id),
            "🐱 **پنل مدیریت ادمین:**\nلطفاً یکی از گزینه‌های زیر را انتخاب کنید:",
            reply_markup=keyboard
        )
        admin_panel_message_id[chat_id] = msg.id
        return

    if raw_text == "گربه ادمین":
        if chat_type != "group":
            await send_and_save(int(chat_id), "⚠️ این دستور فقط در گروه قابل استفاده است.")
            return
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "panel"):
            await send_and_save(int(chat_id), "❌ شما دسترسی به پنل ادمین ندارید.")
            return
        
        if chat_id in admin_panel_message_id:
            try:
                await bot.delete_message(int(chat_id), admin_panel_message_id[chat_id])
            except:
                pass
            admin_panel_message_id.pop(chat_id, None)
        
        keyboard = InlineKeyboard(
            [("📋 لیست تگ", "admin_list")],
            [("🗑️ پاک کن لیست", "admin_clear")],
            [("📊 آمار گروه", "admin_stats")],
            [("👥 مدیریت تحریم‌ها", "admin_ban_list")],
            [("🔧 مدیریت مدیران", "admin_manage_admins")],
            [("🔒 قفل‌ها", "admin_locks")],
            [("❌ بستن پنل", "admin_close")]
        )
        msg = await send_and_save(
            int(chat_id),
            "🐱 **پنل مدیریت ادمین:**\nلطفاً یکی از گزینه‌های زیر را انتخاب کنید:",
            reply_markup=keyboard
        )
        admin_panel_message_id[chat_id] = msg.id
        return

    if chat_type != "group":
        return

    # ===== سایر دستورات =====
    if raw_text.startswith("حالت یادگیری متن تگ"):
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "panel"):
            await send_and_save(int(chat_id), "❌ شما دسترسی لازم را ندارید.")
            return
        template_text = raw_text[len("حالت یادگیری متن تگ"):].strip()
        if not template_text:
            await send_and_save(int(chat_id), "⚠️ لطفاً بعد از «حالت یادگیری متن تگ» یک متن بنویسید.")
            return
        templates[chat_id] = template_text
        save_data()
        await send_and_save(int(chat_id), f"✅ الگوی تگ ذخیره شد:\n\n{template_text}")
        return

    if raw_text == "لیست تگ":
        if chat_id not in collected_members or not collected_members[chat_id]:
            await send_and_save(int(chat_id), "⚠️ لیست تگ خالی است.")
            return
        members_list = "\n".join([f"• @{username}" for username in collected_members[chat_id].values()])
        await send_and_save(int(chat_id), f"📋 **لیست کاربران تگ:**\n\n{members_list}")
        return

    if raw_text.startswith("اضافه کن @"):
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "panel"):
            await send_and_save(int(chat_id), "❌ شما دسترسی لازم را ندارید.")
            return
        target = raw_text.split("@")[1].strip()
        if not target:
            await send_and_save(int(chat_id), "⚠️ لطفاً یک یوزرنیم معتبر وارد کنید.")
            return
        if chat_id not in collected_members:
            collected_members[chat_id] = {}
        collected_members[chat_id][target] = target
        save_data()
        await send_and_save(int(chat_id), f"✅ کاربر @{target} به لیست تگ اضافه شد.")
        return

    if raw_text.startswith("حذف کن @"):
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "panel"):
            await send_and_save(int(chat_id), "❌ شما دسترسی لازم را ندارید.")
            return
        target = raw_text.split("@")[1].strip()
        if not target:
            await send_and_save(int(chat_id), "⚠️ لطفاً یک یوزرنیم یا آیدی معتبر وارد کنید.")
            return
        if chat_id not in collected_members or not collected_members[chat_id]:
            await send_and_save(int(chat_id), "⚠️ لیست تگ خالی است.")
            return
        removed = False
        if target in collected_members[chat_id]:
            del collected_members[chat_id][target]
            removed = True
        else:
            for key, val in list(collected_members[chat_id].items()):
                if val == target:
                    del collected_members[chat_id][key]
                    removed = True
                    break
        if removed:
            save_data()
            await send_and_save(int(chat_id), f"✅ کاربر @{target} از لیست تگ حذف شد.")
        else:
            await send_and_save(int(chat_id), f"⚠️ کاربر @{target} در لیست تگ وجود ندارد.")
        return

    if raw_text == "پاک کن لیست":
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "panel"):
            await send_and_save(int(chat_id), "❌ شما دسترسی لازم را ندارید.")
            return
        if chat_id not in collected_members or not collected_members[chat_id]:
            await send_and_save(int(chat_id), "⚠️ لیست تگ خالی است.")
            return
        collected_members[chat_id].clear()
        save_data()
        await send_and_save(int(chat_id), "🗑️ لیست تگ با موفقیت پاک شد.")
        return

    if raw_text == "تگ":
        if not is_admin(chat_id, user_id):
            current_time = time.time()
            key = f"{chat_id}_{user_id}"
            if key in tag_cooldown:
                last_use = tag_cooldown[key]
                if current_time - last_use < COOLDOWN_SECONDS:
                    remaining = int(COOLDOWN_SECONDS - (current_time - last_use))
                    await send_and_save(int(chat_id), f"⏳ لطفاً {remaining} ثانیه دیگر صبر کنید.")
                    return
            tag_cooldown[key] = current_time
        if chat_id not in collected_members or not collected_members[chat_id]:
            await send_and_save(int(chat_id), "⚠️ لیست تگ خالی است.")
            return
        if chat_id not in templates:
            await send_and_save(int(chat_id), "⚠️ ابتدا الگو را با «حالت یادگیری متن تگ» ثبت کنید.")
            return
        mentions = [f"@{username}" for username in collected_members[chat_id].values()]
        users_text = " ".join(mentions)
        if "{users}" in templates[chat_id]:
            final_text = templates[chat_id].replace("{users}", users_text)
        else:
            final_text = f"{templates[chat_id]}\n\n{users_text}"
        if len(final_text) > 4000:
            final_text = final_text[:3950] + " ..."
        await send_and_save(int(chat_id), final_text)
        return

    if raw_text == "حذف بک‌تیک":
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "delete"):
            await send_and_save(int(chat_id), "❌ شما دسترسی حذف ندارید.")
            return
        
        if chat_id not in message_history or not message_history[chat_id]:
            await send_and_save(int(chat_id), "⚠️ هیچ پیامی برای جستجو وجود ندارد.")
            return
        
        to_delete = []
        for msg in message_history[chat_id]:
            if "`" in msg["text"]:
                to_delete.append(msg["id"])
        
        if not to_delete:
            await send_and_save(int(chat_id), "⚠️ هیچ پیامی با علامت ` یافت نشد.")
            return
        
        deleted = 0
        for msg_id in to_delete:
            try:
                await bot.delete_message(int(chat_id), msg_id)
                deleted += 1
                await asyncio.sleep(0.3)
            except:
                continue
        
        message_history[chat_id] = [msg for msg in message_history[chat_id] if msg["id"] not in to_delete]
        save_history()
        await send_and_save(int(chat_id), f"✅ {deleted} پیام دارای علامت ` حذف شد.")
        return

    if raw_text.startswith("حذف کل "):
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "delete"):
            await send_and_save(int(chat_id), "❌ شما دسترسی حذف ندارید.")
            return
        number_part = raw_text[len("حذف کل "):].strip()
        try:
            count = int(number_part)
            if count > 100:
                await send_and_save(int(chat_id), "⚠️ حداکثر ۱۰۰ پیام می‌توانید حذف کنید.")
                return
            if count < 1:
                await send_and_save(int(chat_id), "⚠️ حداقل ۱ پیام می‌توانید حذف کنید.")
                return
        except ValueError:
            await send_and_save(int(chat_id), "⚠️ لطفاً یک عدد معتبر وارد کنید. مثال: `حذف کل 30`")
            return
        if chat_id not in message_history or not message_history[chat_id]:
            await send_and_save(int(chat_id), "⚠️ هیچ پیامی برای حذف وجود ندارد.")
            return
        deleted = 0
        to_delete = []
        for msg in reversed(message_history[chat_id]):
            if deleted >= count:
                break
            if "sender" in msg:
                to_delete.append(msg["id"])
                deleted += 1
        for msg_id in to_delete:
            try:
                await bot.delete_message(int(chat_id), msg_id)
                await asyncio.sleep(0.3)
            except:
                continue
        message_history[chat_id] = [msg for msg in message_history[chat_id] if msg["id"] not in to_delete]
        save_history()
        if chat_id in admin_panel_state and admin_panel_state.get(chat_id) == user_id:
            admin_panel_state.pop(chat_id, None)
            admin_panel_data.pop(chat_id, None)
        if chat_id in admin_panel_message_id:
            admin_panel_message_id.pop(chat_id, None)
        await send_and_save(int(chat_id), f"✅ {deleted} پیام با موفقیت حذف شد.")
        return

    if raw_text.startswith("حذف ") and not raw_text.startswith("حذف کل "):
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "delete"):
            await send_and_save(int(chat_id), "❌ شما دسترسی حذف ندارید.")
            return
        parts = raw_text.split(maxsplit=1)
        if len(parts) < 2:
            await send_and_save(int(chat_id), "⚠️ نحوه استفاده:\n"
                                  "`حذف 20` → حذف ۲۰ پیام آخر (غیر از ربات)\n"
                                  "`حذف سلام` → حذف پیام‌های دارای متن «سلام»")
            return
        param = parts[1].strip()
        if param.isdigit():
            count = int(param)
            if count > 100:
                await send_and_save(int(chat_id), "⚠️ حداکثر ۱۰۰ پیام می‌توانید حذف کنید.")
                return
            if chat_id not in message_history or not message_history[chat_id]:
                await send_and_save(int(chat_id), "⚠️ هیچ پیامی برای حذف وجود ندارد.")
                return
            deleted = 0
            to_delete = []
            for msg in reversed(message_history[chat_id]):
                if deleted >= count:
                    break
                if msg.get("sender") != "bot":
                    to_delete.append(msg["id"])
                    deleted += 1
            for msg_id in to_delete:
                try:
                    await bot.delete_message(int(chat_id), msg_id)
                    await asyncio.sleep(0.3)
                except:
                    continue
            message_history[chat_id] = [msg for msg in message_history[chat_id] if msg["id"] not in to_delete]
            save_history()
            await send_and_save(int(chat_id), f"✅ {deleted} پیام با موفقیت حذف شد.")
            return
        else:
            target_text = param
            if chat_id not in message_history or not message_history[chat_id]:
                await send_and_save(int(chat_id), "⚠️ هیچ پیامی برای جستجو وجود ندارد.")
                return
            to_delete = []
            for msg in message_history[chat_id]:
                if msg["text"] == target_text:
                    to_delete.append(msg["id"])
            if not to_delete:
                await send_and_save(int(chat_id), f"⚠️ هیچ پیامی با متن «{target_text}» یافت نشد.")
                return
            deleted = 0
            for msg_id in to_delete:
                try:
                    await bot.delete_message(int(chat_id), msg_id)
                    deleted += 1
                    await asyncio.sleep(0.3)
                except:
                    continue
            message_history[chat_id] = [msg for msg in message_history[chat_id] if msg["id"] not in to_delete]
            save_history()
            await send_and_save(int(chat_id), f"✅ {deleted} پیام دارای متن «{target_text}» حذف شد.")
            return

    if raw_text.startswith("تنظیم پسوند "):
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "panel"):
            await send_and_save(int(chat_id), "❌ شما دسترسی قفل ندارید.")
            return
        if chat_id not in locks:
            locks[chat_id] = {}
        ext = raw_text[len("تنظیم پسوند "):].strip()
        if ext.lower() == "حذف":
            locks[chat_id]["extension"] = ""
            await send_and_save(int(chat_id), "📎 پسوند ممنوع حذف شد.")
        else:
            locks[chat_id]["extension"] = ext.lower()
            await send_and_save(int(chat_id), f"📎 پسوند ممنوع '{ext}' تنظیم شد.")
        save_data()
        return

    if cmd == "/lock":
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "panel"):
            await send_and_save(int(chat_id), "❌ شما دسترسی قفل ندارید.")
            return
        if chat_id not in locks:
            locks[chat_id] = {}
        locks[chat_id]["link"] = True
        save_data()
        await send_and_save(int(chat_id), "🔒 قفل لینک فعال شد.")
        return

    if cmd == "/unlock":
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "panel"):
            await send_and_save(int(chat_id), "❌ شما دسترسی قفل ندارید.")
            return
        if chat_id not in locks:
            locks[chat_id] = {}
        locks[chat_id]["link"] = False
        save_data()
        await send_and_save(int(chat_id), "🔓 قفل لینک غیرفعال شد.")
        return

    if raw_text in ["قفل لینک باز", "قفل لینک بسته"]:
        if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "panel"):
            await send_and_save(int(chat_id), "❌ شما دسترسی قفل ندارید.")
            return
        if chat_id not in locks:
            locks[chat_id] = {}
        locks[chat_id]["link"] = (raw_text == "قفل لینک بسته")
        save_data()
        status = "فعال" if locks[chat_id]["link"] else "غیرفعال"
        await send_and_save(int(chat_id), f"🔒 قفل لینک {status} شد.")
        return

    # ===== قفل‌های پیشرفته (با hasattr) =====
    if chat_type == "group" and chat_id in locks:
        lock_settings = locks[chat_id]
        
        if lock_settings.get("link", False) and contains_link(raw_text):
            try:
                await bot.delete_message(int(chat_id), message.id)
                await send_and_save(int(chat_id), f"🚫 @{username} لینک ممنوع!")
            except:
                pass
            return
        
        if lock_settings.get("photo", False) and hasattr(message, 'photo') and message.photo is not None:
            try:
                await bot.delete_message(int(chat_id), message.id)
                await send_and_save(int(chat_id), f"🚫 @{username} ارسال عکس ممنوع!")
            except:
                pass
            return
        
        if lock_settings.get("video", False) and hasattr(message, 'video') and message.video is not None:
            try:
                await bot.delete_message(int(chat_id), message.id)
                await send_and_save(int(chat_id), f"🚫 @{username} ارسال فیلم ممنوع!")
            except:
                pass
            return
        
        if lock_settings.get("file", False) and hasattr(message, 'document') and message.document is not None:
            ext = lock_settings.get("extension", "")
            if ext:
                if message.document.file_name and message.document.file_name.lower().endswith(ext.lower()):
                    try:
                        await bot.delete_message(int(chat_id), message.id)
                        await send_and_save(int(chat_id), f"🚫 @{username} ارسال فایل با پسوند {ext} ممنوع!")
                    except:
                        pass
                    return
            else:
                try:
                    await bot.delete_message(int(chat_id), message.id)
                    await send_and_save(int(chat_id), f"🚫 @{username} ارسال فایل ممنوع!")
                except:
                    pass
                return
        
        if lock_settings.get("forward", False):
            is_forward = False
            if hasattr(message, 'forward_from') and message.forward_from is not None:
                is_forward = True
            elif hasattr(message, 'forward_from_chat') and message.forward_from_chat is not None:
                is_forward = True
            elif hasattr(message, 'forward_origin') and message.forward_origin is not None:
                is_forward = True
            if is_forward:
                try:
                    await bot.delete_message(int(chat_id), message.id)
                    await send_and_save(int(chat_id), f"🚫 @{username} فوروارد ممنوع!")
                except:
                    pass
                return

@bot.on_callback_query()
async def handle_callback(callback_query):
    chat_id = str(callback_query.message.chat.id)
    user_id = str(callback_query.author.id)
    data = callback_query.data

    if not is_admin(chat_id, user_id) and not has_permission(chat_id, user_id, "panel"):
        await bot.answer_callback_query(callback_query.id, text="❌ شما دسترسی به پنل ندارید.", show_alert=True)
        return

    if chat_id in admin_panel_message_id:
        try:
            await bot.delete_message(int(chat_id), admin_panel_message_id[chat_id])
        except:
            pass
        admin_panel_message_id.pop(chat_id, None)

    if data == "admin_close":
        closed_count = 0
        for cid in list(admin_panel_state.keys()):
            if admin_panel_state.get(cid) == user_id:
                admin_panel_state.pop(cid, None)
                admin_panel_data.pop(cid, None)
                closed_count += 1
        if closed_count > 0:
            await bot.send_message(int(chat_id), "🐱 پنل (ها) با موفقیت بسته شدن")
        else:
            await bot.send_message(int(chat_id), "⚠️ شما هیچ پنل بازی ندارید.")
        await bot.answer_callback_query(callback_query.id, text="")
        return

    if data == "admin_back":
        keyboard = InlineKeyboard(
            [("📋 لیست تگ", "admin_list")],
            [("🗑️ پاک کن لیست", "admin_clear")],
            [("📊 آمار گروه", "admin_stats")],
            [("👥 مدیریت تحریم‌ها", "admin_ban_list")],
            [("🔧 مدیریت مدیران", "admin_manage_admins")],
            [("🔒 قفل‌ها", "admin_locks")],
            [("❌ بستن پنل", "admin_close")]
        )
        msg = await send_and_save(
            int(chat_id),
            "🐱 **پنل مدیریت ادمین:**\nلطفاً یکی از گزینه‌های زیر را انتخاب کنید:",
            reply_markup=keyboard
        )
        admin_panel_message_id[chat_id] = msg.id
        await bot.answer_callback_query(callback_query.id, text="")
        return

    if data == "admin_back_from_ban":
        admin_panel_state.pop(chat_id, None)
        admin_panel_data.pop(chat_id, None)
        keyboard = InlineKeyboard(
            [("📋 لیست تگ", "admin_list")],
            [("🗑️ پاک کن لیست", "admin_clear")],
            [("📊 آمار گروه", "admin_stats")],
            [("👥 مدیریت تحریم‌ها", "admin_ban_list")],
            [("🔧 مدیریت مدیران", "admin_manage_admins")],
            [("🔒 قفل‌ها", "admin_locks")],
            [("❌ بستن پنل", "admin_close")]
        )
        msg = await send_and_save(
            int(chat_id),
            "🐱 **پنل مدیریت ادمین:**\nلطفاً یکی از گزینه‌های زیر را انتخاب کنید:",
            reply_markup=keyboard
        )
        admin_panel_message_id[chat_id] = msg.id
        await bot.answer_callback_query(callback_query.id, text="")
        return

    if data == "admin_list":
        if chat_id not in collected_members or not collected_members[chat_id]:
            msg = await send_and_save(int(chat_id), "⚠️ لیست تگ خالی است.")
        else:
            members_list = "\n".join([f"• @{username}" for username in collected_members[chat_id].values()])
            keyboard = InlineKeyboard(
                [("🔙 برگشت به پنل", "admin_back")]
            )
            msg = await send_and_save(
                int(chat_id),
                f"📋 **لیست کاربران تگ:**\n\n{members_list}",
                reply_markup=keyboard
            )
        admin_panel_message_id[chat_id] = msg.id
        await bot.answer_callback_query(callback_query.id, text="")
        return

    if data == "admin_clear":
        if chat_id in collected_members:
            collected_members[chat_id].clear()
            save_data()
            text = "🗑️ لیست تگ با موفقیت پاک شد."
        else:
            text = "⚠️ لیست تگ خالی است."
        keyboard = InlineKeyboard(
            [("🔙 برگشت به پنل", "admin_back")]
        )
        msg = await send_and_save(int(chat_id), text, reply_markup=keyboard)
        admin_panel_message_id[chat_id] = msg.id
        await bot.answer_callback_query(callback_query.id, text="")
        return

    if data == "admin_stats":
        total_members = len(collected_members.get(chat_id, {}))
        total_banned = len(banned_users.get(chat_id, {}))
        total_muted = len(muted_users.get(chat_id, {}))
        is_locked = locks.get(chat_id, {}).get("link", False)
        lock_status = "🔒 فعال" if is_locked else "🔓 غیرفعال"
        stats_text = f"📊 **آمار گروه:**\n\n"
        stats_text += f"👥 کل کاربران تگ: {total_members}\n"
        stats_text += f"🚫 کاربران بن‌شده: {total_banned}\n"
        stats_text += f"🔇 کاربران سکوت‌شده: {total_muted}\n"
        stats_text += f"🔒 وضعیت قفل لینک: {lock_status}"
        keyboard = InlineKeyboard(
            [("🔙 برگشت به پنل", "admin_back")]
        )
        msg = await send_and_save(int(chat_id), stats_text, reply_markup=keyboard)
        admin_panel_message_id[chat_id] = msg.id
        await bot.answer_callback_query(callback_query.id, text="")
        return

    if data == "admin_ban_list":
        if chat_id in admin_panel_message_id:
            try:
                await bot.delete_message(int(chat_id), admin_panel_message_id[chat_id])
            except:
                pass
            admin_panel_message_id.pop(chat_id, None)
        
        banned_list = banned_users.get(chat_id, {})
        muted_list = muted_users.get(chat_id, {})
        all_restricted = {}
        for uid in banned_list:
            all_restricted[uid] = {"type": "🚫 بن", "id": uid}
        for uid in muted_list:
            if uid not in all_restricted:
                all_restricted[uid] = {"type": "🔇 سکوت", "id": uid}
            else:
                all_restricted[uid]["type"] = "🚫 بن + 🔇 سکوت"
        
        if not all_restricted:
            keyboard = InlineKeyboard(
                [("🔙 برگشت به پنل", "admin_back")]
            )
            msg = await send_and_save(int(chat_id), "✅ هیچ کاربر تحریم‌شده‌ای در گروه وجود ندارد.", reply_markup=keyboard)
            admin_panel_message_id[chat_id] = msg.id
            await bot.answer_callback_query(callback_query.id, text="")
            return
        
        buttons = []
        for uid, info in all_restricted.items():
            name = get_username(chat_id, uid)
            label = f"{info['type']} | {name}"
            buttons.append([InlineKeyboardButton(label, callback_data=f"unban_{uid}")])
        buttons.append([InlineKeyboardButton("🔙 برگشت به پنل", callback_data="admin_back")])
        
        keyboard = InlineKeyboard(*buttons)
        msg = await send_and_save(
            int(chat_id),
            "👥 **لیست کاربران تحریم‌شده:**\nروی هر کاربر کلیک کنید تا آنبن شود.",
            reply_markup=keyboard
        )
        admin_panel_message_id[chat_id] = msg.id
        await bot.answer_callback_query(callback_query.id, text="")
        return

    if data.startswith("unban_"):
        if chat_id in admin_panel_message_id:
            try:
                await bot.delete_message(int(chat_id), admin_panel_message_id[chat_id])
            except:
                pass
            admin_panel_message_id.pop(chat_id, None)
        
        target_uid = data.replace("unban_", "")
        name = get_username(chat_id, target_uid)
        
        removed_banned = False
        removed_muted = False
        if chat_id in banned_users and target_uid in banned_users[chat_id]:
            del banned_users[chat_id][target_uid]
            removed_banned = True
        if chat_id in muted_users and target_uid in muted_users[chat_id]:
            del muted_users[chat_id][target_uid]
            removed_muted = True
        
        if removed_banned or removed_muted:
            save_data()
            msg = f"✅ تحریم کاربر {name} برداشته شد."
            if removed_banned and removed_muted:
                msg = f"✅ بن و سکوت کاربر {name} برداشته شد."
            elif removed_banned:
                msg = f"✅ بن کاربر {name} برداشته شد."
            elif removed_muted:
                msg = f"✅ سکوت کاربر {name} برداشته شد."
            await bot.send_message(int(chat_id), msg)
        else:
            await bot.send_message(int(chat_id), f"⚠️ کاربر {name} در لیست تحریم‌ها وجود ندارد.")
        
        banned_list = banned_users.get(chat_id, {})
        muted_list = muted_users.get(chat_id, {})
        all_restricted = {}
        for uid in banned_list:
            all_restricted[uid] = {"type": "🚫 بن", "id": uid}
        for uid in muted_list:
            if uid not in all_restricted:
                all_restricted[uid] = {"type": "🔇 سکوت", "id": uid}
            else:
                all_restricted[uid]["type"] = "🚫 بن + 🔇 سکوت"
        
        if not all_restricted:
            keyboard = InlineKeyboard(
                [("🔙 برگشت به پنل", "admin_back")]
            )
            msg = await send_and_save(int(chat_id), "✅ هیچ کاربر تحریم‌شده‌ای در گروه وجود ندارد.", reply_markup=keyboard)
            admin_panel_message_id[chat_id] = msg.id
            await bot.answer_callback_query(callback_query.id, text="")
            return
        
        buttons = []
        for uid, info in all_restricted.items():
            name = get_username(chat_id, uid)
            label = f"{info['type']} | {name}"
            buttons.append([InlineKeyboardButton(label, callback_data=f"unban_{uid}")])
        buttons.append([InlineKeyboardButton("🔙 برگشت به پنل", callback_data="admin_back")])
        
        keyboard = InlineKeyboard(*buttons)
        msg = await send_and_save(
            int(chat_id),
            "👥 **لیست کاربران تحریم‌شده (به‌روز):**\nروی هر کاربر کلیک کنید تا آنبن شود.",
            reply_markup=keyboard
        )
        admin_panel_message_id[chat_id] = msg.id
        await bot.answer_callback_query(callback_query.id, text="")
        return

    if data == "admin_manage_admins":
        if not is_owner(chat_id, user_id):
            await bot.send_message(int(chat_id), "❌ فقط مالک گروه می‌تواند مدیران را مدیریت کند.")
            await bot.answer_callback_query(callback_query.id, text="")
            return
        
        admin_list = admin_permissions.get(chat_id, {})
        if not admin_list:
            keyboard = InlineKeyboard(
                [("🔙 برگشت به پنل", "admin_back")]
            )
            msg = await send_and_save(int(chat_id), "📋 **لیست مدیران:**\nهیچ مدیری تعیین نشده است.", reply_markup=keyboard)
            admin_panel_message_id[chat_id] = msg.id
            await bot.answer_callback_query(callback_query.id, text="")
            return
        
        buttons = []
        for uid, perms in admin_list.items():
            name = get_username(chat_id, uid)
            buttons.append([InlineKeyboardButton(f"👤 {name}", callback_data=f"admin_perm_{uid}")])
        buttons.append([InlineKeyboardButton("🔙 برگشت به پنل", callback_data="admin_back")])
        
        keyboard = InlineKeyboard(*buttons)
        msg = await send_and_save(
            int(chat_id),
            "👥 **لیست مدیران:**\nروی هر مدیر کلیک کنید تا دسترسی‌هایش را تنظیم کنید.",
            reply_markup=keyboard
        )
        admin_panel_message_id[chat_id] = msg.id
        await bot.answer_callback_query(callback_query.id, text="")
        return

    if data.startswith("admin_perm_"):
        if not is_owner(chat_id, user_id):
            await bot.send_message(int(chat_id), "❌ فقط مالک گروه می‌تواند دسترسی‌ها را تنظیم کند.")
            await bot.answer_callback_query(callback_query.id, text="")
            return
        
        target_uid = data.replace("admin_perm_", "")
        if target_uid not in admin_permissions.get(chat_id, {}):
            await bot.send_message(int(chat_id), "⚠️ این کاربر در لیست مدیران نیست.")
            await bot.answer_callback_query(callback_query.id, text="")
            return
        
        perms = admin_permissions[chat_id][target_uid]
        name = get_username(chat_id, target_uid)
        
        panel_status = "✅" if perms.get("panel") else "❌"
        delete_status = "✅" if perms.get("delete") else "❌"
        pin_status = "✅" if perms.get("pin") else "❌"
        ban_status = "✅" if perms.get("ban") else "❌"
        
        keyboard = InlineKeyboard(
            [("🔹 پنل: " + panel_status, f"admin_toggle_{target_uid}_panel")],
            [("🔹 حذف: " + delete_status, f"admin_toggle_{target_uid}_delete")],
            [("🔹 پین: " + pin_status, f"admin_toggle_{target_uid}_pin")],
            [("🔹 بن: " + ban_status, f"admin_toggle_{target_uid}_ban")],
            [("🔙 برگشت به لیست مدیران", "admin_manage_admins")]
        )
        msg = await send_and_save(
            int(chat_id),
            f"🔧 **تنظیم دسترسی‌های {name}**\n\nروی هر دکمه کلیک کنید تا وضعیت آن تغییر کند.",
            reply_markup=keyboard
        )
        admin_panel_message_id[chat_id] = msg.id
        await bot.answer_callback_query(callback_query.id, text="")
        return

    if data.startswith("admin_toggle_"):
        if not is_owner(chat_id, user_id):
            await bot.send_message(int(chat_id), "❌ فقط مالک گروه می‌تواند دسترسی‌ها را تنظیم کند.")
            await bot.answer_callback_query(callback_query.id, text="")
            return
        
        parts = data.split("_")
        target_uid = parts[2]
        perm = parts[3]
        
        if target_uid not in admin_permissions.get(chat_id, {}):
            await bot.send_message(int(chat_id), "⚠️ این کاربر در لیست مدیران نیست.")
            await bot.answer_callback_query(callback_query.id, text="")
            return
        
        admin_permissions[chat_id][target_uid][perm] = not admin_permissions[chat_id][target_uid].get(perm, False)
        save_data()
        
        perms = admin_permissions[chat_id][target_uid]
        name = get_username(chat_id, target_uid)
        
        panel_status = "✅" if perms.get("panel") else "❌"
        delete_status = "✅" if perms.get("delete") else "❌"
        pin_status = "✅" if perms.get("pin") else "❌"
        ban_status = "✅" if perms.get("ban") else "❌"
        
        keyboard = InlineKeyboard(
            [("🔹 پنل: " + panel_status, f"admin_toggle_{target_uid}_panel")],
            [("🔹 حذف: " + delete_status, f"admin_toggle_{target_uid}_delete")],
            [("🔹 پین: " + pin_status, f"admin_toggle_{target_uid}_pin")],
            [("🔹 بن: " + ban_status, f"admin_toggle_{target_uid}_ban")],
            [("🔙 برگشت به لیست مدیران", "admin_manage_admins")]
        )
        msg = await send_and_save(
            int(chat_id),
            f"🔧 **تنظیم دسترسی‌های {name}**\n\n✅ تغییرات اعمال شد.",
            reply_markup=keyboard
        )
        admin_panel_message_id[chat_id] = msg.id
        await bot.answer_callback_query(callback_query.id, text="")
        return

    if data == "admin_locks":
        lock_settings = locks.get(chat_id, {})
        status = lambda x: "✅ فعال" if x else "❌ غیرفعال"
        text = "🔒 **مدیریت قفل‌های گروه:**\n\n"
        text += f"🔗 لینک: {status(lock_settings.get('link', False))}\n"
        text += f"🖼️ عکس: {status(lock_settings.get('photo', False))}\n"
        text += f"🎬 فیلم: {status(lock_settings.get('video', False))}\n"
        text += f"📁 فایل: {status(lock_settings.get('file', False))}\n"
        text += f"↗️ فوروارد: {status(lock_settings.get('forward', False))}\n"
        text += f"📎 پسوند ممنوع: {lock_settings.get('extension', 'ندارد')}\n\n"
        text += "برای تغییر هر کدام، روی دکمه مربوطه کلیک کنید."
        
        keyboard = InlineKeyboard(
            [("🔗 لینک", "lock_toggle_link")],
            [("🖼️ عکس", "lock_toggle_photo")],
            [("🎬 فیلم", "lock_toggle_video")],
            [("📁 فایل", "lock_toggle_file")],
            [("↗️ فوروارد", "lock_toggle_forward")],
            [("📎 تنظیم پسوند", "lock_set_extension")],
            [("🔙 برگشت به پنل", "admin_back")]
        )
        msg = await send_and_save(int(chat_id), text, reply_markup=keyboard)
        admin_panel_message_id[chat_id] = msg.id
        await bot.answer_callback_query(callback_query.id, text="")
        return

    if data.startswith("lock_toggle_"):
        lock_type = data.replace("lock_toggle_", "")
        if chat_id not in locks:
            locks[chat_id] = {}
        locks[chat_id][lock_type] = not locks[chat_id].get(lock_type, False)
        save_data()
        
        lock_settings = locks.get(chat_id, {})
        status = lambda x: "✅ فعال" if x else "❌ غیرفعال"
        text = "🔒 **مدیریت قفل‌های گروه:**\n\n"
        text += f"🔗 لینک: {status(lock_settings.get('link', False))}\n"
        text += f"🖼️ عکس: {status(lock_settings.get('photo', False))}\n"
        text += f"🎬 فیلم: {status(lock_settings.get('video', False))}\n"
        text += f"📁 فایل: {status(lock_settings.get('file', False))}\n"
        text += f"↗️ فوروارد: {status(lock_settings.get('forward', False))}\n"
        text += f"📎 پسوند ممنوع: {lock_settings.get('extension', 'ندارد')}\n\n"
        text += "✅ تغییرات اعمال شد."
        
        keyboard = InlineKeyboard(
            [("🔗 لینک", "lock_toggle_link")],
            [("🖼️ عکس", "lock_toggle_photo")],
            [("🎬 فیلم", "lock_toggle_video")],
            [("📁 فایل", "lock_toggle_file")],
            [("↗️ فوروارد", "lock_toggle_forward")],
            [("📎 تنظیم پسوند", "lock_set_extension")],
            [("🔙 برگشت به پنل", "admin_back")]
        )
        msg = await send_and_save(int(chat_id), text, reply_markup=keyboard)
        admin_panel_message_id[chat_id] = msg.id
        await bot.answer_callback_query(callback_query.id, text="")
        return

    if data == "lock_set_extension":
        await bot.send_message(int(chat_id), 
            "📎 **تنظیم پسوند ممنوع:**\n\n"
            "لطفاً پسوند مورد نظر را به صورت زیر وارد کنید:\n"
            "`تنظیم پسوند .exe`\n\n"
            "برای حذف پسوند، بنویسید:\n"
            "`تنظیم پسوند حذف`"
        )
        await bot.answer_callback_query(callback_query.id, text="")
        return

    await bot.answer_callback_query(callback_query.id, text="")

if __name__ == "__main__":
    print("🤖 ربات DeadBale نسخه نهایی اجرا شد!")
    bot.run()