import os
import json
import time
import asyncio
from telethon import events
from telethon.tl.types import PeerChannel
import requests
import sqlite3
from telethon.tl.types import MessageEntityBold, MessageEntityItalic, MessageEntityUnderline, MessageEntitySpoiler
from telethon.tl.functions.contacts import BlockRequest, UnblockRequest
from telethon.tl.functions.account import CheckUsernameRequest
import random
from telethon.tl.functions.messages import SendReactionRequest
from telethon.tl.types import ReactionEmoji
from datetime import datetime
from telethon.tl.functions.channels import GetParticipantRequest, EditBannedRequest, EditAdminRequest
from telethon.tl.types import ChatBannedRights, ChatAdminRights, ChannelParticipantAdmin, ChannelParticipantCreator
from telethon.tl.functions.messages import DeleteHistoryRequest                 from telethon.errors import ChatAdminRequiredError, UserAdminInvalidError, FloodWaitError                                                                       from PIL import Image, ImageDraw, ImageFont
from telethon.tl import types                                                   from telethon import errors
                                                                                DOWNLOAD_FOLDER = "downloads"
if not os.path.exists(DOWNLOAD_FOLDER):                                             os.makedirs(DOWNLOAD_FOLDER)

rafigh = False
friends_list = {}
friends_texts = {}
friends_index = {}

doshman_enabled = False
doshman_list = {}        # {my_id: [enemy_ids]}
doshman_texts = {}       # {my_id: [texts]}
doshman_index = {}       # {enemy_id: index}

auto_read_enabled = False                                                       
global_banner_enabled = False
async def setup_reactions(client, my_id, phone):


    # ===================== سیو گیف =====================
    @client.on(events.NewMessage(outgoing=True, pattern=r"^\.سیو گیف$"))
    async def save_gif_handler(event):

        if not event.is_reply:
            await event.edit(" روی یک گیف ریپلای کنید!")
            return

        replied = await event.get_reply_message()

        if not replied.media:
            await event.edit(" این پیام مدیا ندارد!")
            return

        await event.edit("● در حال سیو گیف ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

        try:
            file_name = f"gif_{int(time.time())}"
            file_path = await client.download_media(
                replied,
                file=os.path.join(DOWNLOAD_FOLDER, file_name)
            )

            if not file_path or not os.path.exists(file_path):
                await event.edit("❌ خطا در دانلود گیف!")
                return

            sender = await replied.get_sender()                                             sender_name = sender.first_name if sender else "نامشخص"
            sender_id = sender.id if sender else "نامشخص"

            chat = await event.get_chat()
            chat_name = getattr(chat, "title", "پیوی")

            caption = (
                f"● گیف سیو شده\n\n"                                                            f"● از: {sender_name}\n"
                f"● آیدی: {sender_id}\n"                                                        f"● چت: {chat_name}\n"
                f"● تاریخ: {time.strftime('%Y/%m/%d - %H:%M:%S')}"
            )

            await client.send_file("me", file_path, caption=caption)
            os.remove(file_path)

            await event.edit("● گیف سیو شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
            await asyncio.sleep(2)
            await event.delete()
                                                                                        except Exception as e:
            await event.edit(f"❌ خطا: {e}")                                    
                                                                                    # ===================== اسکرین شات =====================
    @client.on(events.NewMessage(outgoing=True, pattern=r"^\.اسکرین(?: (\d+))?$"))                                                                                  async def screenshot_last_messages(event):
        # گرفتن عدد پیام‌ها
        count = event.pattern_match.group(1)                                            if count is None:
            count = 10  # پیش‌فرض
        else:
            count = int(count)

        await event.edit(f"●درحال گرفتن اسکرین{count}پیام♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡")

        try:
            chat = await event.get_chat()
            messages = await client.get_messages(chat, limit=count)

            # ساخت خطوط
            lines = []
            lines.append(f"💬 آخرین {count} پیام:")
            lines.append("┏━━━━━━━━━━━━━━━━━━━━━━━━━┓")

            index = 1
            for msg in messages[::-1]:                                                          sender = await msg.get_sender()
                name = sender.first_name if sender else "ناشناس"                                text = msg.message if msg.message else "—"
                time = msg.date.strftime("%H:%M")
                mid = msg.id

                lines.append(f"┃ {index}. 👤 {name}")
                lines.append(f"┃    💬 {text}")
                lines.append(f"┃    ⏰ {time} | 🆔 {mid}")
                lines.append("┃    ─────────────────")

                index += 1                                                      
            lines.append("┗━━━━━━━━━━━━━━━━━━━━━━━━━┛")

            # صفحه‌بندی — هر پیام حداکثر 3500 کاراکتر
            chunk = ""
            chunks = []

            for line in lines:
                if len(chunk) + len(line) + 2 > 3500:
                    chunks.append(chunk)
                    chunk = ""
                chunk += line + "\n"

            if chunk:
                chunks.append(chunk)

            # ارسال صفحه‌ها
            await event.edit("● در حال ارسال اسکرین ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
                                                                                            for part in chunks:
                await client.send_message("me", part)

            await event.edit("● اسکرین ارسال شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
            await asyncio.sleep(2)
            await event.delete()

        except Exception as e:
            await event.edit(f"❌ خطا: {e}")

    #========= دانلود ویس یک‌بار مصرف =========
    voice_download_enabled = False

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.دانلود ویس روشن$'))
    async def voice_download_on(event):
        nonlocal voice_download_enabled
        if event.sender_id != my_id:
            return
        voice_download_enabled = True
        await event.edit("● دانلود ویس مدیا روشن شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.دانلود ویس خاموش$'))
    async def voice_download_off(event):                                                nonlocal voice_download_enabled
        if event.sender_id != my_id:                                                        return
        voice_download_enabled = False
        await event.edit("● دانلود ویس مدیا خاموش شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(incoming=True))
    async def voice_download_handler(event):
        if not voice_download_enabled:
            return
        msg = event.message                                                             if not msg.media:
            return
        if not msg.voice:
            return
        if not getattr(msg.media, 'ttl_seconds', None):
            return
        try:
            file = await client.download_media(msg)
            await client.send_file("me", file, voice_note=True, caption=" ویس یک‌بار مصرف ذخیره شد")
        except Exception as e:
            print(f"خطا در ذخیره ویس: {e}")

    #========= قیمت ارز =========                                                   COIN_IDS = {
        "btc": "bitcoin",
        "eth": "ethereum",
        "ton": "the-open-network",
        "usdt": "tether",
        "bnb": "binancecoin",
        "sol": "solana",
        "xrp": "ripple",
        "doge": "dogecoin",
        "ada": "cardano",
        "trx": "tron",
        "not": "notcoin",
    }

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.قیمت ارز (.+)$'))
    async def price_handler(event):
        if event.sender_id != my_id:
            return
        symbol = event.pattern_match.group(1).strip().lower()
        coin = COIN_IDS.get(symbol, symbol)
        await event.edit("●در حال دریافت قیمت♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
        try:
            url = f"https://api.coingecko.com/api/v3/simple/price?ids={coin}&vs_currencies=usd"
            data = requests.get(url).json()
            if coin not in data:
                await event.edit("❌ ارز موردنظر پیدا نشد! نام صحیح را وارد کن.")
                return
            price_usd = data[coin]["usd"]
            price_toman = int(price_usd * 60000)
            await event.edit(
                f"● قیمت لحظه‌ای {symbol.upper()}:\n"
                f"➖➖➖➖➖\n"
                f"● قیمت دلاری: {price_usd}\n"
                f"● قیمت به تومان: {price_toman:,} تومان\n"
                f"➖➖➖➖➖\n"
                f"♕ 𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ♕"
            )
        except Exception as e:
            await event.edit(f"❌ خطا در دریافت قیمت: {e}")

    #========= دیتابیس منشی (با پشتیبانی مدیا) =========
    SECRETARY_DB = "secretary_v2.db"

    def init_secretary_db():
        conn = sqlite3.connect(SECRETARY_DB)
        c = conn.cursor()
        c.execute("""
            CREATE TABLE IF NOT EXISTS secretary (
                owner_phone TEXT PRIMARY KEY,
                enabled INTEGER,
                text TEXT,
                media_chat_id INTEGER,
                media_msg_id INTEGER,
                media_type TEXT
            )
        """)
        conn.commit()
        conn.close()

    init_secretary_db()

    def save_secretary(owner_phone, enabled, text, media_chat_id, media_msg_id, media_type):
        conn = sqlite3.connect(SECRETARY_DB)
        c = conn.cursor()
        c.execute("DELETE FROM secretary WHERE owner_phone = ?", (owner_phone,))
        c.execute(
            "INSERT INTO secretary (owner_phone, enabled, text, media_chat_id, media_msg_id, media_type) VALUES (?, ?, ?, ?, ?, ?)",
            (owner_phone, int(enabled), text, media_chat_id, media_msg_id, media_type)
        )
        conn.commit()
        conn.close()

    def get_secretary(owner_phone):
        conn = sqlite3.connect(SECRETARY_DB)
        c = conn.cursor()
        c.execute("SELECT enabled, text, media_chat_id, media_msg_id, media_type FROM secretary WHERE owner_phone = ?", (owner_phone,))
        r = c.fetchone()
        conn.close()
        if r:
            return {"enabled": bool(r[0]), "text": r[1], "media_chat_id": r[2], "media_msg_id": r[3], "media_type": r[4]}
        return {"enabled": False, "text": None, "media_chat_id": None, "media_msg_id": None, "media_type": None}

    def clear_secretary(owner_phone):
        conn = sqlite3.connect(SECRETARY_DB)
        c = conn.cursor()
        c.execute("DELETE FROM secretary WHERE owner_phone = ?", (owner_phone,))
        conn.commit()
        conn.close()

    #========= دستورات منشی =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.تنظیم متن منشی$'))
    async def set_secretary(event):
        if event.sender_id != my_id:
            return
        if not event.is_reply:
            await event.edit(" روی یک پیام ریپلای کنید تا به عنوان پاسخ منشی تنظیم شود!")
            return

        reply = await event.get_reply_message()
        if not reply:
            await event.edit(" پیام ریپلای شده پیدا نشد!")
            return

        text = reply.text or ""
        media_chat_id = None
        media_msg_id = None
        media_type = " متن"

        if reply.media:
            media_chat_id = event.chat_id
            media_msg_id = reply.id
            if reply.photo:
                media_type = "📸 عکس"
            elif reply.video:
                media_type = "🎬 ویدیو"
            elif reply.audio:
                media_type = "🎵 صوت"
            elif reply.document:
                media_type = "📄 فایل"

        current = get_secretary(phone)
        save_secretary(phone, current["enabled"], text, media_chat_id, media_msg_id, media_type)

        await event.edit(f"● متن منشی تنظیم شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ●\n نوع: {media_type}\n متن: {text[:50] if text else 'ندارد'}")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.منشی روشن$'))
    async def enable_secretary(event):
        if event.sender_id != my_id:
            return
        current = get_secretary(phone)
        if not current["text"] and not current["media_msg_id"]:
            await event.edit(" ابتدا منشی را تنظیم کنید!\nبا .منشی روی یک پیام ریپلای کنید.")
            return
        save_secretary(phone, True, current["text"], current["media_chat_id"], current["media_msg_id"], current["media_type"])
        await event.edit("● منشی روشن شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.منشی خاموش$'))
    async def disable_secretary(event):
        if event.sender_id != my_id:
            return
        current = get_secretary(phone)
        save_secretary(phone, False, current["text"], current["media_chat_id"], current["media_msg_id"], current["media_type"])
        await event.edit("● منشی خاموش شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.منشی وضعیت$'))
    async def secretary_status(event):
        if event.sender_id != my_id:
            return
        current = get_secretary(phone)
        status = "● روشن" if current["enabled"] else "🔴 خاموش"
        has_text = "●" if current["text"] else "❌"
        has_media = "●" if current["media_msg_id"] else "❌"

        text = f" وضعیت منشی\n\n"
        text += f"┃ وضعیت: {status}\n"                                                  text += f"┃ نوع: {current['media_type'] or 'تنظیم نشده'}\n"
        text += f"┃ متن: {has_text}\n"
        text += f"┃ مدیا: {has_media}\n"
        if current["text"]:
            text += f"┃ 📝 متن: {current['text'][:50]}\n"

        await event.edit(text)

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.منشی حذف$'))
    async def delete_secretary(event):
        if event.sender_id != my_id:
            return
        clear_secretary(phone)
        await event.edit("● متن منشی حذف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.منشی لیست$'))
    async def secretary_list(event):
        if event.sender_id != my_id:
            return
        current = get_secretary(phone)
        if not current["text"] and not current["media_msg_id"]:
            await event.edit("📭 هیچ منشی تنظیم نشده است!")
            return

        status = "🟢 روشن" if current["enabled"] else "🔴 خاموش"
        text = f" لیست منشی تنظیم شده\n\n"
        text += f"┃ وضعیت: {status}\n"
        text += f"┃ نوع: {current['media_type'] or 'نامشخص'}\n"
        if current["text"]:
            text += f"┃  متن: {current['text']}\n"
        if current["media_msg_id"]:
            text += f"┃  مدیا: ✅\n"

        await event.edit(text)

    #========= هندلر منشی (ورودی) =========
    @client.on(events.NewMessage(incoming=True))
    async def secretary_handler(event):
        if not event.is_private:
            return
        if event.sender_id == my_id:
            return

        current = get_secretary(phone)
        if not current["enabled"]:
            return

        try:
            if current["text"]:
                await client.send_message(event.chat_id, current["text"])

            if current["media_msg_id"]:
                try:
                    media_msg = await client.get_messages(current["media_chat_id"], ids=current["media_msg_id"])
                    if media_msg and media_msg.media:
                        await client.send_file(event.chat_id, media_msg.media)
                except Exception as e:
                    print(f"خطا در ارسال مدیای منشی: {e}")

        except Exception as e:
            print(f"Secretary error: {e}")

    #========= سکوت (فقط پیوی) =========
    MUTE_DB = "mute.db"

    def init_mute_db():
        conn = sqlite3.connect(MUTE_DB)
        c = conn.cursor()
        c.execute("""
            CREATE TABLE IF NOT EXISTS muted (
                owner_phone TEXT,
                user_id INTEGER,
                UNIQUE(owner_phone, user_id)
            )
        """)
        conn.commit()
        conn.close()

    init_mute_db()

    def mute_user(owner_phone, uid):
        conn = sqlite3.connect(MUTE_DB)
        c = conn.cursor()
        try:
            c.execute("INSERT INTO muted (owner_phone, user_id) VALUES (?, ?)", (owner_phone, uid))
            conn.commit()
        except:
            pass
        conn.close()

    def unmute_user(owner_phone, uid):
        conn = sqlite3.connect(MUTE_DB)
        c = conn.cursor()
        c.execute("DELETE FROM muted WHERE owner_phone = ? AND user_id = ?", (owner_phone, uid))
        conn.commit()
        conn.close()

    def is_muted(owner_phone, uid):
        conn = sqlite3.connect(MUTE_DB)
        c = conn.cursor()
        c.execute("SELECT user_id FROM muted WHERE owner_phone = ? AND user_id = ?", (owner_phone, uid))
        r = c.fetchone()
        conn.close()
        return bool(r)

    def get_muted_list(owner_phone):
        conn = sqlite3.connect(MUTE_DB)
        c = conn.cursor()
        c.execute("SELECT user_id FROM muted WHERE owner_phone = ?", (owner_phone,))
        r = c.fetchall()
        conn.close()
        return [i[0] for i in r]

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.سکوت$'))
    async def mute_handler(event):
        if event.sender_id != my_id:
            return
        if not event.is_reply:
            await event.edit(" باید روی پیام کاربر ریپلای بزنی!")
            return
        reply = await event.get_reply_message()
        uid = reply.sender_id
        mute_user(phone, uid)
        await event.edit("● کاربر سکوت شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.حذف سکوت$'))
    async def unmute_handler(event):
        if event.sender_id != my_id:
            return
        if not event.is_reply:
            await event.edit(" باید روی پیام کاربر ریپلای بزنی!")
            return
        reply = await event.get_reply_message()
        uid = reply.sender_id
        unmute_user(phone, uid)
        await event.edit("● کاربر از سکوت خراج شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.لیست سکوت$'))
    async def mute_list_handler(event):
        if event.sender_id != my_id:
            return
        muted = get_muted_list(phone)
        if not muted:
            await event.edit("📋 هیچ کاربری سکوت نشده!")
            return
        text = "● لیست کاربران سکوت‌شده:\n\n"
        for i, uid in enumerate(muted, 1):
            try:
                user = await client.get_entity(uid)
                name = user.first_name or "بدون نام"
            except:
                name = "نامشخص"
            text += f"{i}. {name} | {uid}\n"
        await event.edit(text)

    @client.on(events.NewMessage(incoming=True))
    async def mute_delete_handler(event):
        if not event.is_private:
            return
        if event.sender_id == my_id:
            return
        if is_muted(phone, event.sender_id):
            try:
                await event.delete()
            except Exception as e:
                print(f"خطا در حذف پیام سکوت: {e}")

    #========= حالت متن =========
    spoiler_enabled = False
    bold_enabled = False
    italic_enabled = False
    underline_enabled = False

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.اسپویلر روشن$'))
    async def spoiler_on(event):
        nonlocal spoiler_enabled
        if event.sender_id != my_id:
            return
        spoiler_enabled = True
        await event.edit("● اسپویلر روشن شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.اسپویلر خاموش$'))
    async def spoiler_off(event):
        nonlocal spoiler_enabled
        if event.sender_id != my_id:
            return
        spoiler_enabled = False
        await event.edit("● اسپویلر خاموش شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.بولد روشن$'))
    async def bold_on(event):
        nonlocal bold_enabled
        if event.sender_id != my_id:
            return
        bold_enabled = True
        await event.edit("● بولد روشن شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.بولد خاموش$'))
    async def bold_off(event):
        nonlocal bold_enabled
        if event.sender_id != my_id:
            return
        bold_enabled = False
        await event.edit("● بولد خاموش شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.ایتالیک روشن$'))
    async def italic_on(event):
        nonlocal italic_enabled
        if event.sender_id != my_id:
            return
        italic_enabled = True
        await event.edit("● ایتالیک روشن شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.ایتالیک خاموش$'))
    async def italic_off(event):
        nonlocal italic_enabled
        if event.sender_id != my_id:
            return
        italic_enabled = False
        await event.edit("● ایتالیک خاموش شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.آندرلاین روشن$'))
    async def underline_on(event):
        nonlocal underline_enabled
        if event.sender_id != my_id:
            return
        underline_enabled = True
        await event.edit("● آندرلاین روشن شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.آندرلاین خاموش$'))
    async def underline_off(event):
        nonlocal underline_enabled
        if event.sender_id != my_id:
            return
        underline_enabled = False
        await event.edit("● آندرلاین خاموش شد ♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ●")

    @client.on(events.NewMessage(outgoing=True))
    async def text_format_handler(event):
        if not any([spoiler_enabled, bold_enabled, italic_enabled, underline_enabled]):
            return
        text = event.message.message
        if not text or text.startswith("."):
            return
        length = len(text)
        entities = []
        if bold_enabled:
            entities.append(MessageEntityBold(0, length))
        if italic_enabled:
            entities.append(MessageEntityItalic(0, length))
        if underline_enabled:
            entities.append(MessageEntityUnderline(0, length))
        if spoiler_enabled:
            entities.append(MessageEntitySpoiler(0, length))
        try:
            await client.edit_message(event.chat_id, event.id, text, formatting_entities=entities)
        except Exception as e:
            print(f"خطا در فرمت متن: {e}")                                      
    #========= فیلتر کلمات (پیوی) =========
    FILTER_DB = "word_filter.db"

    def init_filter_db():
        conn = sqlite3.connect(FILTER_DB)
        c = conn.cursor()
        c.execute("""
            CREATE TABLE IF NOT EXISTS filtered_words (
                owner_phone TEXT,
                word TEXT,
                UNIQUE(owner_phone, word)
            )
        """)
        conn.commit()
        conn.close()

    init_filter_db()

    def add_filter_word(owner_phone, word):
        conn = sqlite3.connect(FILTER_DB)
        c = conn.cursor()
        try:
            c.execute("INSERT INTO filtered_words (owner_phone, word) VALUES (?, ?)", (owner_phone, word))
            conn.commit()
        except:
            pass
        conn.close()

    def remove_filter_word(owner_phone, word):
        conn = sqlite3.connect(FILTER_DB)
        c = conn.cursor()
        c.execute("DELETE FROM filtered_words WHERE owner_phone = ? AND word = ?", (owner_phone, word))
        conn.commit()
        conn.close()

    def get_filter_words(owner_phone):
        conn = sqlite3.connect(FILTER_DB)
        c = conn.cursor()
        c.execute("SELECT word FROM filtered_words WHERE owner_phone = ?", (owner_phone,))
        r = c.fetchall()
        conn.close()
        return [i[0] for i in r]

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.فیلتر کلمه (.+)$'))
    async def add_filter_handler(event):
        if event.sender_id != my_id:
            return
        word = event.pattern_match.group(1).strip()
        add_filter_word(phone, word)
        await event.edit(f"●کلمه«{word}»فیلتر شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.حذف فیلتر (.+)$'))
    async def remove_filter_handler(event):
        if event.sender_id != my_id:
            return
        word = event.pattern_match.group(1).strip()
        remove_filter_word(phone, word)
        await event.edit(f"●کلمه«{word}»حذف فیلتر شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.لیست فیلتر کلمات$'))
    async def list_filter_handler(event):
        if event.sender_id != my_id:
            return
        words = get_filter_words(phone)
        if not words:
            await event.edit(" هیچ کلمه‌ای فیلتر نشده!")
            return
        text = "● لیست کلمات فیلترشده:\n\n"
        for i, w in enumerate(words, 1):
            text += f"{i}. {w}\n"                                                       await event.edit(text)

    @client.on(events.NewMessage(incoming=True))
    async def filter_delete_handler(event):
        if not event.is_private:
            return
        if event.sender_id == my_id:
            return
        text = event.message.message
        if not text:
            return
        words = get_filter_words(phone)
        if not words:
            return
        for w in words:
            if w in text:
                try:
                    await event.delete()
                except Exception as e:
                    print(f"خطا در حذف پیام فیلترشده: {e}")                                     break
                                                                                #==================== قابلیت بلاک ====================

    block_db_path = "block_db.json"

    # ساخت دیتابیس اگر وجود نداشت                                                   if not os.path.exists(block_db_path):
        with open(block_db_path, "w") as f:
            json.dump([], f)

    def save_block_db(data):
        with open(block_db_path, "w") as f:
            json.dump(data, f)                                                  
    def load_block_db():
        with open(block_db_path, "r") as f:
            return json.load(f)

    #========= بلاک =========
    @client.on(events.NewMessage(outgoing=True, pattern=r"^\.بلاک$"))
    async def block_user(event):
        if event.sender_id != my_id:
            return

        if not event.is_reply:
            await event.edit("لطفاً روی پیام کاربر ریپلای بزن")
            return

        reply = await event.get_reply_message()
        user_id = reply.sender_id

        # بلاک واقعی
        try:
            await client(BlockRequest(user_id))
        except Exception as e:                                                              await event.edit(f" خطا در بلاک: {e}")
            return

        # ذخیره در دیتابیس                                                              db = load_block_db()
        if user_id not in db:                                                               db.append(user_id)
            save_block_db(db)

        await event.edit(f"●کاربر{user_id}بلاک شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    #========= آنبلاک =========
    @client.on(events.NewMessage(outgoing=True, pattern=r"^\.انبلاک$"))
    async def unblock_user(event):
        if event.sender_id != my_id:
            return
                                                                                        if not event.is_reply:
            await event.edit(" لطفاً روی پیام کاربر ریپلای بزن")
            return

        reply = await event.get_reply_message()
        user_id = reply.sender_id

        # آنبلاک واقعی
        try:
            await client(UnblockRequest(user_id))
        except Exception as e:
            await event.edit(f"خطا در آنبلاک: {e}")
            return

        # حذف از دیتابیس
        db = load_block_db()
        if user_id in db:
            db.remove(user_id)
            save_block_db(db)

        await event.edit(f"●کاربر{user_id}آنبلاک شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    #========= لیست بلاک =========
    @client.on(events.NewMessage(outgoing=True, pattern=r"^\.لیست بلاک$"))          async def block_list(event):
        if event.sender_id != my_id:
            return
                                                                                        db = load_block_db()
                                                                                        if not db:
            await event.edit("لیست بلاک خالی است")
            return

        text = "لیست کاربران بلاک شده:\n\n"
        for uid in db:
            text += f"• {uid}\n"

        await event.edit(text)

    #========= فونت انگلیسی =========
    def make_english_font(text, offset_upper, offset_lower, offset_digit=None):
        result = ""
        for ch in text:
            if 'A' <= ch <= 'Z':
                result += chr(ord(ch) - ord('A') + offset_upper)
            elif 'a' <= ch <= 'z':
                result += chr(ord(ch) - ord('a') + offset_lower)
            elif ch.isdigit() and offset_digit:
                result += chr(ord(ch) - ord('0') + offset_digit)
            else:
                result += ch
        return result

    ENGLISH_FONTS = [
        ("بولد", 0x1D400, 0x1D41A, 0x1D7CE),
        ("ایتالیک", 0x1D434, 0x1D44E, None),
        ("بولد ایتالیک", 0x1D468, 0x1D482, None),
        ("اسکریپت", 0x1D49C, 0x1D4B6, None),
        ("بولد اسکریپت", 0x1D4D0, 0x1D4EA, None),
        ("فراکتور", 0x1D504, 0x1D51E, None),
        ("بولد فراکتور", 0x1D56C, 0x1D586, None),
        ("دبل‌استراک", 0x1D538, 0x1D552, 0x1D7D8),
        ("سنس‌سریف", 0x1D5A0, 0x1D5BA, 0x1D7E2),
        ("مونواسپیس", 0x1D670, 0x1D68A, 0x1D7F6),
    ]

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.فونت (.+)$'))
    async def english_font_handler(event):
        if event.sender_id != my_id:
            return
        text = event.pattern_match.group(1).strip()
        await event.delete()

        result = "● فونت‌های انگلیسی:\n\n"
        for name, up, low, dig in ENGLISH_FONTS:
            styled = make_english_font(text, up, low, dig)
            result += f"{styled}\n"

        await client.send_message(event.chat_id, result)
                                                                                    #========= انیمیشن عکاسی =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.عکاسی$'))
    async def camera_animation(event):
        if event.sender_id != my_id:
            return
        try:
            await event.edit("📷 بیا یه عکس ازت بگیرم")
            await asyncio.sleep(2)

            await event.edit(" لبخند بزن")
            await asyncio.sleep(2)                                              
            await event.edit("😄")
            await asyncio.sleep(3)

            await event.edit("📸")                                                          await asyncio.sleep(2)

            await event.edit("🖼 عکستو ببین")
            await asyncio.sleep(2)
                                                                                            await event.edit("�")
        except Exception as e:
            print(f"خطا در انیمیشن: {e}")

    #========= انیمیشن رقص =========                                                @client.on(events.NewMessage(outgoing=True, pattern=r'^\.رقص$'))
    async def dance_animation(event):
        if event.sender_id != my_id:
            return
        SP = "\u2800"
        frames = [
            f"💃 💃 💃{SP*12}",
            f"{SP*2}💃 💃 💃{SP*10}",
            f"{SP*4}💃 💃 💃{SP*8}",
            f"{SP*6}💃 💃 💃{SP*6}",                                                        f"{SP*4}💃 💃 💃{SP*8}",
            f"{SP*2}💃 💃 💃{SP*10}",
            f"💃 💃 💃{SP*12}",
            "💋",
        ]
        try:
            await event.edit(frames[0])
            for frame in frames[1:]:
                await asyncio.sleep(0.7)
                await event.edit(frame)
        except Exception as e:
            print(f"خطا در انیمیشن رقص: {e}")
                                                                                    #========= انیمیشن قلب =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.قلب$'))                async def heart_animation(event):
        if event.sender_id != my_id:
            return
        SP = "\u2800"                                                           
        row1 = "💚🤍❤️�💙💜�"                                                            row2 = "�💜💙�❤️🤍💚"
        row3 = "�💚💙🤍💜❤️�"
        hearts = ["💚", "🤍", "❤️", "�", "💙", "💜", "�"]

        shape1 = (                                                                          f"{SP*2}❤️�{SP*2}❤️�\n"
            f"❤️�❤️�❤️�\n"
            f"{SP*2}�❤️�❤️\n"
            f"{SP*4}💜"
        )

        shape2 = (
            f"{SP*4}💙\n"
            f"{SP*2}💙💜💙\n"
            f"💙💜�💜💙\n"
            f"{SP*2}💜�💜\n"
            f"{SP*4}�"
        )

        try:
            # مرحله ۱: سه آرایش مختلف ردیف
            await event.edit(row1)
            await asyncio.sleep(1)

            await event.edit(row2)
            await asyncio.sleep(1)

            await event.edit(row3)
            await asyncio.sleep(1)

            # مرحله ۲: قلب‌ها تک‌تک به ترتیب
            for h in hearts:
                await asyncio.sleep(0.5)
                await event.edit(h)

            await asyncio.sleep(1)

            # مرحله ۳: شکل‌ها
            await event.edit(shape1)
            await asyncio.sleep(1.5)

            await event.edit(shape2)
            await asyncio.sleep(1.5)

            # مرحله ۴: نهایی
            await event.edit("💓")
        except Exception as e:
            print(f"خطا در انیمیشن قلب: {e}")

    #========= لیست ایموجی‌های مجاز تلگرام برای ری‌اکشن =========
    ALLOWED_REACTIONS = [
        "❤️", "👍", "👎", "🔥", "🥰", "👏", "😁", "🤔", "🤯", "😱",
        "🤬", "😢", "🎉", "🤩", "🤮", "💩", "🙏", "👌", "🕊", "🤡",
        "🥱", "🥴", "😍", "🐳", "🌚", "🌭", "💯", "🤣", "⚡",
        "🍌", "🏆", "💔", "🤨", "😐", "🍓", "🍾", "💋", "🖕", "😈",
        "😴", "😭", "🤓", "👻", "👀", "🎃", "🙈", "😇", "😨",
        "🤝", "🤗", "🎅", "🎄", "☃️", "💅", "🤪", "🗿",
        "🆒", "💘", "🙉", "🦄", "😘", "💊", "🙊", "😎", "👾",
        "😡",
    ]

    #========= دیتابیس ری‌اکشن =========
    REACTION_DB = "reaction.db"

    def init_reaction_db():
        conn = sqlite3.connect(REACTION_DB)
        c = conn.cursor()
        c.execute("""
            CREATE TABLE IF NOT EXISTS reaction_emojis (
                owner_phone TEXT,
                emoji TEXT,
                UNIQUE(owner_phone, emoji)
            )
        """)
        c.execute("""
            CREATE TABLE IF NOT EXISTS reaction_settings (
                owner_phone TEXT PRIMARY KEY,
                enabled INTEGER
            )
        """)
        conn.commit()
        conn.close()
                                                                                    init_reaction_db()
                                                                                    def add_reaction_emoji(owner_phone, emoji):
        conn = sqlite3.connect(REACTION_DB)                                             c = conn.cursor()
        try:                                                                                c.execute("INSERT INTO reaction_emojis (owner_phone, emoji) VALUES (?, ?)", (owner_phone, emoji))                                                               conn.commit()
        except:                                                                             pass
        conn.close()
                                                                                    def remove_reaction_emoji(owner_phone, emoji):
        conn = sqlite3.connect(REACTION_DB)                                             c = conn.cursor()
        c.execute("DELETE FROM reaction_emojis WHERE owner_phone = ? AND emoji = ?", (owner_phone, emoji))
        conn.commit()                                                                   conn.close()

    def get_reaction_emojis(owner_phone):
        conn = sqlite3.connect(REACTION_DB)
        c = conn.cursor()
        c.execute("SELECT emoji FROM reaction_emojis WHERE owner_phone = ?", (owner_phone,))
        r = c.fetchall()
        conn.close()
        return [i[0] for i in r]

    def set_reaction_enabled(owner_phone, enabled):
        conn = sqlite3.connect(REACTION_DB)
        c = conn.cursor()
        c.execute("DELETE FROM reaction_settings WHERE owner_phone = ?", (owner_phone,))
        c.execute("INSERT INTO reaction_settings (owner_phone, enabled) VALUES (?, ?)", (owner_phone, int(enabled)))
        conn.commit()
        conn.close()

    def get_reaction_enabled(owner_phone):                                              conn = sqlite3.connect(REACTION_DB)
        c = conn.cursor()                                                               c.execute("SELECT enabled FROM reaction_settings WHERE owner_phone = ?", (owner_phone,))                                                                        r = c.fetchone()
        conn.close()                                                                    return bool(r[0]) if r else False
                                                                                    #========= دستورات ری‌اکشن =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.تنظیم ری[\s‌]?اکشن (.+)$'))                                                                             async def set_reaction_handler(event):
        if event.sender_id != my_id:                                                        return
        emoji = event.pattern_match.group(1).strip()
        if emoji not in ALLOWED_REACTIONS:
            await event.edit(f"❌ این ایموجی پشتیبانی نمی‌شه! یکی از این‌ها رو انتخاب کن:\n\n{' '.join(ALLOWED_REACTIONS)}")
            return
        add_reaction_emoji(phone, emoji)
        await event.edit(f"●ری‌اکشن{emoji}تنظیم شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.حذف ری[\s‌]?اکشن (.+)$'))
    async def remove_reaction_handler(event):
        if event.sender_id != my_id:
            return
        emoji = event.pattern_match.group(1).strip()
        remove_reaction_emoji(phone, emoji)
        await event.edit(f"●ری‌اکشن{emoji}حذف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.لیست ری[\s‌]?اکشن$'))
    async def list_reaction_handler(event):
        if event.sender_id != my_id:
            return
        emojis = get_reaction_emojis(phone)
        if not emojis:
            await event.edit("هیچ ری‌اکشنی تنظیم نشده!")
            return
        text = "لیست ری‌اکشن‌ها:\n\n"
        for i, e in enumerate(emojis, 1):
            text += f"{i}. {e}\n"
        await event.edit(text)

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.ری[\s‌]?اکشن خودکار روشن$'))
    async def reaction_auto_on(event):
        if event.sender_id != my_id:
            return
        emojis = get_reaction_emojis(phone)
        if not emojis:
            await event.edit("❌ اول باید با .تنظیم ری‌اکشن یه ایموجی تنظیم کنی!")
            return
        set_reaction_enabled(phone, True)
        await event.edit("●ری‌اکشن خودکار روشن شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.ری[\s‌]?اکشن خودکار خاموش$'))
    async def reaction_auto_off(event):
        if event.sender_id != my_id:
            return
        set_reaction_enabled(phone, False)
        await event.edit("●ری‌اکشن خودکار خاموش شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    #========= صف سراسری + مدیریت flood wait =========
    reaction_lock = asyncio.Lock()
    last_reaction_time = {"t": 0}
    reaction_paused_until = {"t": 0}

    @client.on(events.NewMessage(incoming=True))
    async def auto_reaction_handler(event):
        if event.sender_id == my_id:
            return
        if event.message.action is not None:
            return
        if not get_reaction_enabled(phone):
            return
        emojis = get_reaction_emojis(phone)
        if not emojis:
            return

        now_check = asyncio.get_event_loop().time()
        if now_check < reaction_paused_until["t"]:
            return

        try:
            async with reaction_lock:
                now = asyncio.get_event_loop().time()
                if now < reaction_paused_until["t"]:
                    return

                wait_needed = 5 - (now - last_reaction_time["t"])
                if wait_needed > 0:
                    await asyncio.sleep(wait_needed)

                chosen = random.choice(emojis)                                                  chosen_clean = chosen.replace("\ufe0f", "")

                peer = await event.get_input_chat()
                await client(SendReactionRequest(
                    peer=peer,
                    msg_id=event.id,
                    reaction=[ReactionEmoji(emoticon=chosen_clean)]
                ))
                last_reaction_time["t"] = asyncio.get_event_loop().time()

        except errors.FloodWaitError as e:
            reaction_paused_until["t"] = asyncio.get_event_loop().time() + e.seconds
            print(f"⏸ ری‌اکشن به مدت {e.seconds} ثانیه متوقف شد (flood wait)")
        except Exception as e:
            error_text = str(e)
            if "can't write" in error_text.lower() or "message id is invalid" in error_text.lower():
                pass
            else:
                print(f"خطا در ری‌اکشن خودکار ({event.chat_id}): {e}")

    # ===================== تبچی =====================                              banners = {}
    banner_settings = {}
    banner_tasks = {}
    banner_stats = {}


    async def send_banner_task(chat_id):
        while True:
            if chat_id not in banner_settings:
                await asyncio.sleep(5)
                continue

            if not banner_settings[chat_id].get("enabled", False):
                await asyncio.sleep(5)
                continue

            if not global_banner_enabled:
                await asyncio.sleep(5)
                continue

            banner_num = banner_settings[chat_id]["banner_number"]
            banner_data = banners.get(banner_num)

            if not banner_data:
                await asyncio.sleep(5)
                continue

            try:
                if banner_data.get("media"):
                    await client.send_file(
                        chat_id,
                        banner_data["media"],
                        caption=banner_data.get("text", "") or ""
                    )
                else:
                    await client.send_message(
                        chat_id,
                        banner_data.get("text", "") or "تبلیغ"
                    )

                banner_stats[banner_num]["sent_count"] += 1
                banner_stats[banner_num]["last_sent"] = datetime.now().strftime("%H:%M:%S")

                interval = banner_settings[chat_id].get("interval", 30)
                await asyncio.sleep(interval)

            except Exception:
                await asyncio.sleep(10)


    @client.on(events.NewMessage(outgoing=True, pattern=r"^\.تنظیم بنر کپی$"))
    async def set_banner_copy(event):
        if not event.is_reply:
            await event.edit(" روی یک پیام ریپلای کنید!")
            return

        reply = await event.get_reply_message()

        banner_num = 1
        while banner_num in banners:
            banner_num += 1

        if banner_num > 20:
            await event.edit(" حداکثر 20 بنر قابل ذخیره است!")
            return

        media_type = None
        media_icon = ""

        if reply.photo:
            media_type = "photo"
            media_icon = "📸"
        elif reply.video:
            media_type = "video"
            media_icon = "🎬"
        elif reply.document and reply.document.mime_type and "gif" in reply.document.mime_type.lower():
            media_type = "gif"
            media_icon = "🎞️"
        elif reply.document:
            media_type = "document"
            media_icon = "📄"

        banners[banner_num] = {
            "chat_id": event.chat_id,
            "message_id": reply.id,
            "media": reply.media,
            "text": reply.text or "",
            "media_type": media_type,
            "media_icon": media_icon
        }

        banner_stats[banner_num] = {
            "sent_count": 0,
            "last_sent": None,
            "chats_count": 0
        }

        await event.edit(f"●بنر شماره{banner_num}ذخیره شد{media_icon}♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")


    @client.on(events.NewMessage(outgoing=True, pattern=r"^\.تبچی روشن$"))
    async def enable_banner_global(event):
        global global_banner_enabled

        if not banners:
            await event.edit("ابتدا یک بنر تنظیم کنید!")
            return

        global_banner_enabled = True

        for chat_id, setting in banner_settings.items():
            if setting.get("enabled") and chat_id not in banner_tasks:
                task = asyncio.create_task(send_banner_task(chat_id))
                banner_tasks[chat_id] = task

        await event.edit("●تبچی روشن شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")


    @client.on(events.NewMessage(outgoing=True, pattern=r"^\.تبچی خاموش$"))
    async def disable_banner_global(event):
        global global_banner_enabled

        global_banner_enabled = False

        for chat_id in list(banner_tasks.keys()):
            try:
                banner_tasks[chat_id].cancel()
            except:
                pass
                                                                                        banner_tasks.clear()

        await event.edit("●تبچی خاموش شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")


    @client.on(events.NewMessage(outgoing=True, pattern=r"^\.تنظیم بنر (\d+) در این چت$"))
    async def set_banner_this_chat(event):
        num = int(event.pattern_match.group(1))
        chat_id = event.chat_id

        if num not in banners:
            await event.edit("این بنر وجود ندارد!")
            return                                                              
        banner_settings[chat_id] = {
            "banner_number": num,
            "enabled": True,
            "interval": 30
        }

        banner_stats[num]["chats_count"] += 1

        if global_banner_enabled and chat_id not in banner_tasks:
            task = asyncio.create_task(send_banner_task(chat_id))
            banner_tasks[chat_id] = task

        await event.edit(f"●بنر{num}در این چت تنظقم شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")



    @client.on(events.NewMessage(outgoing=True, pattern=r"^\.تایم بنر (\d+) (\d+)$"))
    async def set_banner_interval(event):
        num = int(event.pattern_match.group(1))
        interval = int(event.pattern_match.group(2))

        if num not in banners:
            await event.edit("این بنر وجود ندارد!")
            return

        for chat_id in banner_settings:
            if banner_settings[chat_id]["banner_number"] == num:                                banner_settings[chat_id]["interval"] = interval

        await event.edit(f"●تایم بنر{num}روی{interval}ثانیه تنظیم شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")



    @client.on(events.NewMessage(outgoing=True, pattern=r"^\.لیست بنر ها$"))
    async def list_banners(event):
        if not banners:
            await event.edit("هیچ بنری ذخیره نشده.")
            return

        text = "لیست بنرها:\n\n"

        for num, data in banners.items():
            stats = banner_stats[num]
            text += f"بنر {num} {data['media_icon']}\n"
            text += f" {data['text'][:50]}...\n"
            text += f" ارسال: {stats['sent_count']} | گروه‌ها: {stats['chats_count']}\n"                                                                                     if stats["last_sent"]:
                text += f" آخرین ارسال: {stats['last_sent']}\n"
            text += "───────────────\n"

        await event.edit(text)                                                  
    #========= توابع کمکی مدیریت گروه =========
    async def get_user_from_input(event, input_text=None):
        user_id = None
        if event.is_reply:
            reply = await event.get_reply_message()
            if reply:
                user_id = reply.sender_id
        if not user_id and input_text:
            try:
                if input_text.isdigit():
                    user_id = int(input_text)
                else:
                    entity = await client.get_entity(input_text)
                    user_id = entity.id
            except:
                pass
        return user_id

    async def check_is_admin(chat_id, user_id):
        try:
            participant = await client(GetParticipantRequest(chat_id, user_id))
            return isinstance(participant.participant, (ChannelParticipantAdmin, ChannelParticipantCreator))
        except:
            return False

    async def check_is_owner(chat_id, user_id):
        try:                                                                                participant = await client(GetParticipantRequest(chat_id, user_id))
            return isinstance(participant.participant, ChannelParticipantCreator)
        except:
            return False

    #========= بن/آنبن =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.ban\s*(.*)$'))
    async def ban_user(event):
        if event.sender_id != my_id:
            return
        if not event.chat_id < 0:
            await event.edit(" فقط در گروه!")
            return

        target = event.pattern_match.group(1).strip() if event.pattern_match.group(1) else None
        user_id = await get_user_from_input(event, target)
        if not user_id:
            await event.edit(" کاربر را مشخص کنید!\n.ban @username یا ریپلای")
            return

        try:
            if not await check_is_admin(event.chat_id, my_id):
                await event.edit(" سلف بات ادمین نیست!")
                return
            if user_id == my_id:
                await event.edit(" نمی‌توانید خودتان را بن کنید!")
                return
            if await check_is_admin(event.chat_id, user_id):
                await event.edit(" نمی‌توانید ادمین را بن کنید!")
                return

            rights = ChatBannedRights(
                until_date=None, view_messages=True, send_messages=True,
                send_media=True, send_stickers=True, send_gifs=True,
                send_games=True, send_inline=True, send_polls=True,
                change_info=True, invite_users=True, pin_messages=True
            )
            await client(EditBannedRequest(event.chat_id, user_id, rights))

            try:
                user = await client.get_entity(user_id)
                name = user.first_name or "کاربر"
            except:
                name = f"کاربر {user_id}"

            await event.edit(f"●{name}بن شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
        except ChatAdminRequiredError:
            await event.edit("سلف بات ادمین نیست!")
        except UserAdminInvalidError:
            await event.edit("نمی‌توانید ادمین را بن کنید!")
        except Exception as e:
            await event.edit(f"خطا: {str(e)}")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.unban\s*(.*)$'))
    async def unban_user(event):
        if event.sender_id != my_id:                                                        return
        if not event.chat_id < 0:                                                           await event.edit("فقط در گروه!")
            return

        target = event.pattern_match.group(1).strip() if event.pattern_match.group(1) else None
        user_id = await get_user_from_input(event, target)                              if not user_id:
            await event.edit("کاربر را مشخص کنید!\n.unban @username یا ریپلای")
            return
                                                                                        try:
            if not await check_is_admin(event.chat_id, my_id):                                  await event.edit("سلف بات ادمین نیست!")
                return

            rights = ChatBannedRights(                                                          until_date=None, view_messages=False, send_messages=False,
                send_media=False, send_stickers=False, send_gifs=False,                         send_games=False, send_inline=False, send_polls=False,
                change_info=False, invite_users=False, pin_messages=False
            )
            await client(EditBannedRequest(event.chat_id, user_id, rights))

            try:
                user = await client.get_entity(user_id)
                name = user.first_name or "کاربر"
            except:
                name = f"کاربر {user_id}"

            await event.edit(f"●کاربر{name}آنبن شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
        except ChatAdminRequiredError:
            await event.edit("سلف بات ادمین نیست!")
        except Exception as e:
            await event.edit(f"خطا: {str(e)}")

    #========= سکوت/رفع سکوت =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.setmute\s*(.*)$'))
    async def mute_user(event):
        if event.sender_id != my_id:
            return
        if not event.chat_id < 0:
            await event.edit("فقط در گروه!")
            return

        target = event.pattern_match.group(1).strip() if event.pattern_match.group(1) else None
        user_id = await get_user_from_input(event, target)
        if not user_id:
            await event.edit("کاربر را مشخص کنید!\n.setmute @username یا ریپلای")
            return

        try:
            if not await check_is_admin(event.chat_id, my_id):
                await event.edit("سلف بات ادمین نیست!")
                return
            if user_id == my_id:
                await event.edit("نمی‌توانید خودتان را سکوت کنید!")
                return
            if await check_is_admin(event.chat_id, user_id):
                await event.edit("نمی‌توانید ادمین را سکوت کنید!")
                return

            rights = ChatBannedRights(
                until_date=None, view_messages=False, send_messages=True,
                send_media=True, send_stickers=True, send_gifs=True,
                send_games=True, send_inline=True, send_polls=True,
                change_info=False, invite_users=False, pin_messages=False
            )                                                                               await client(EditBannedRequest(event.chat_id, user_id, rights))

            try:
                user = await client.get_entity(user_id)
                name = user.first_name or "کاربر"
            except:
                name = f"کاربر {user_id}"

            await event.edit(f"●کاربر{name}سکوت شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
        except ChatAdminRequiredError:
            await event.edit("سلف بات ادمین نیست!")
        except Exception as e:
            await event.edit(f" خطا: {str(e)}")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.delmute\s*(.*)$'))
    async def unmute_user(event):
        if event.sender_id != my_id:
            return
        if not event.chat_id < 0:
            await event.edit("فقط در گروه!")
            return

        target = event.pattern_match.group(1).strip() if event.pattern_match.group(1) else None
        user_id = await get_user_from_input(event, target)
        if not user_id:
            await event.edit(" کاربر را مشخص کنید!\n.delmute @username یا ریپلای")
            return

        try:
            if not await check_is_admin(event.chat_id, my_id):
                await event.edit("سلف بات ادمین نیست!")
                return

            rights = ChatBannedRights(
                until_date=None, view_messages=False, send_messages=False,                      send_media=False, send_stickers=False, send_gifs=False,
                send_games=False, send_inline=False, send_polls=False,
                change_info=False, invite_users=False, pin_messages=False
            )                                                                               await client(EditBannedRequest(event.chat_id, user_id, rights))

            try:
                user = await client.get_entity(user_id)
                name = user.first_name or "کاربر"                                           except:
                name = f"کاربر {user_id}"

            await event.edit(f"●سکوت{name}برداشته شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
        except ChatAdminRequiredError:
            await event.edit("سلف بات ادمین نیست!")
        except Exception as e:
            await event.edit(f"خطا: {str(e)}")

    #========= افزودن/حذف ادمین =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.addadmin\s*(.*)$'))
    async def add_admin(event):
        if event.sender_id != my_id:
            return
        if not event.chat_id < 0:
            await event.edit("فقط در گروه!")
            return

        target = event.pattern_match.group(1).strip() if event.pattern_match.group(1) else None
        user_id = await get_user_from_input(event, target)
        if not user_id:
            await event.edit("کاربر را مشخص کنید!\n.addadmin @username یا ریپلای کنید")
            return

        try:
            if not await check_is_admin(event.chat_id, my_id):
                await event.edit("سلف بات ادمین نیست!")
                return

            try:
                await client(GetParticipantRequest(event.chat_id, user_id))
            except:
                await event.edit("کاربر در گروه نیست!")
                return

            if await check_is_admin(event.chat_id, user_id):
                await event.edit("این کاربر قبلاً ادمین است!")
                return

            rights = ChatAdminRights(
                change_info=True, post_messages=True, edit_messages=True,
                delete_messages=True, ban_users=True, invite_users=True,
                pin_messages=True, add_admins=False, anonymous=False,
                manage_call=True, other=True
            )                                                                   
            await client(EditAdminRequest(
                channel=event.chat_id, user_id=user_id,
                admin_rights=rights, rank="مدیر"
            ))

            try:
                user = await client.get_entity(user_id)
                name = user.first_name or "کاربر"
                if user.username:
                    name += f" (@{user.username})"
            except:
                name = f"کاربر {user_id}"

            await event.edit(f"●کاربر{name}ادمین شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
        except ChatAdminRequiredError:
            await event.edit("سلف بات ادمین نیست!")
        except Exception as e:
            await event.edit(f"خطا: {str(e)}")
                                                                                    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.removeadmin\s*(.*)$'))
    async def remove_admin(event):
        if event.sender_id != my_id:
            return
        if not event.chat_id < 0:
            await event.edit("فقط در گروه!")
            return

        target = event.pattern_match.group(1).strip() if event.pattern_match.group(1) else None
        user_id = await get_user_from_input(event, target)
        if not user_id:
            await event.edit("کاربر را مشخص کنید!\n.removeadmin @username یا ریپلای کنید")
            return

        try:
            if not await check_is_admin(event.chat_id, my_id):
                await event.edit("سلف بات ادمین نیست!")
                return
            if user_id == my_id:
                await event.edit("نمی‌توانید سلف بات را حذف کنید!")
                return
            if not await check_is_admin(event.chat_id, user_id):
                await event.edit("این کاربر ادمین نیست!")                                       return
            if await check_is_owner(event.chat_id, user_id):                                    await event.edit("نمی‌توانید مالک گروه را حذف کنید!")
                return                                                          
            rights = ChatAdminRights(
                change_info=False, post_messages=False, edit_messages=False,
                delete_messages=False, ban_users=False, invite_users=False,
                pin_messages=False, add_admins=False, anonymous=False,
                manage_call=False, other=False
            )

            await client(EditAdminRequest(
                channel=event.chat_id, user_id=user_id,
                admin_rights=rights, rank="عضو"
            ))

            try:
                user = await client.get_entity(user_id)
                name = user.first_name or "کاربر"
                if user.username:
                    name += f" (@{user.username})"
            except:
                name = f"کاربر {user_id}"

            await event.edit(f"●کاربر{name}از ادمینی حذف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
        except ChatAdminRequiredError:
            await event.edit("سلف بات ادمین نیست!")
        except Exception as e:
            await event.edit(f"خطا: {str(e)}")

    #========= لیست ادمین‌ها =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.ادمین‌ها$'))
    async def list_admins(event):
        if event.sender_id != my_id:
            return
        if not event.chat_id < 0:
            await event.edit("فقط در گروه!")
            return

        await event.edit("●در حال دریافت لیست ادمین‌ها♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

        try:
            admins = []
            async for admin in client.iter_participants(event.chat_id, filter=ChannelParticipantAdmin):
                admins.append(admin)

            if not admins:
                await event.edit("هیچ ادمینی در گروه نیست!")
                return

            text = "لیست کامل ادمین‌ها\n\n"
            text += f"تعداد: {len(admins)}\n"
            text += "━━━━━━━━━━━━━━━━━━━━\n\n"

            for i, admin in enumerate(admins, 1):
                name = admin.first_name or "ادمین"
                if admin.last_name:
                    name += f" {admin.last_name}"

                is_owner_flag = await check_is_owner(event.chat_id, admin.id)
                owner_tag = " مالک" if is_owner_flag else ""

                if admin.username:
                    text += f"{i}. [{name}](tg://user?id={admin.id}) - @{admin.username}{owner_tag}\n"
                else:
                    text += f"{i}. [{name}](tg://user?id={admin.id}){owner_tag}\n"

            await event.edit(text, parse_mode="markdown", link_preview=False)
        except Exception as e:
            await event.edit(f"خطا: {str(e)}")

    #========= سنجاق =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.pin$'))
    async def pin_message(event):
        if event.sender_id != my_id:
            return
        if not event.chat_id < 0:
            await event.edit(" فقط در گروه!")
            return
        if not event.is_reply:
            await event.edit(" روی پیام ریپلای کنید!")
            return

        try:
            if not await check_is_admin(event.chat_id, my_id):
                await event.edit("سلف بات ادمین نیست!")
                return                                                          
            reply = await event.get_reply_message()                                         await client.pin_message(event.chat_id, reply.id)
            await event.edit("●سنجاق شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
        except ChatAdminRequiredError:
            await event.edit("سلف بات ادمین نیست!")
        except Exception as e:
            await event.edit(f"خطا: {str(e)}")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.unpin$'))
    async def unpin_message(event):
        if event.sender_id != my_id:
            return
        if not event.chat_id < 0:
            await event.edit("فقط در گروه!")
            return
        if not event.is_reply:                                                              await event.edit("روی پیام ریپلای کنید!")
            return                                                              
        try:
            if not await check_is_admin(event.chat_id, my_id):
                await event.edit("سلف بات ادمین نیست!")                                         return
                                                                                            reply = await event.get_reply_message()
            await client.unpin_message(event.chat_id, reply.id)
            await event.edit("●سنجاق حذف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
        except ChatAdminRequiredError:                                                      await event.edit("سلف بات ادمین نیست!")
        except Exception as e:                                                              await event.edit(f"خطا: {str(e)}")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.unpinall$'))
    async def unpin_all_messages(event):                                                if event.sender_id != my_id:
            return                                                                      if not event.chat_id < 0:
            await event.edit("فقط در گروه!")
            return
                                                                                        try:
            if not await check_is_admin(event.chat_id, my_id):                                  await event.edit("سلف بات ادمین نیست!")
                return

            await client.unpin_message(event.chat_id)                                       await event.edit("●همه سنجاق‌ها حذف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
        except ChatAdminRequiredError:                                                      await event.edit("سلف بات ادمین نیست!")
        except Exception as e:
            await event.edit(f"خطا: {str(e)}")

    #========= حذف پیام =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.del$'))
    async def delete_one_message(event):
        if event.sender_id != my_id:
            return
        if not event.is_reply:
            await event.edit("روی پیام ریپلای کنید!")
            return

        try:
            reply = await event.get_reply_message()
            await client.delete_messages(event.chat_id, [reply.id])
            await event.delete()
        except Exception as e:
            await event.edit(f"خطا: {str(e)}")                                  
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.delete\s*(\d+)$'))     async def delete_messages_group(event):
        if event.sender_id != my_id:                                                        return
        if not event.chat_id < 0:
            await event.edit("فقط در گروه!")
            return

        count = int(event.pattern_match.group(1))
        if count > 500:
            await event.edit("حداکثر 500!")
            return

        try:
            if not await check_is_admin(event.chat_id, my_id):
                await event.edit("سلف بات ادمین نیست!")
                return                                                          
            msgs = []
            async for msg in client.iter_messages(event.chat_id, limit=count):
                if msg.sender_id == my_id:                                                          msgs.append(msg)
            if msgs:
                await client.delete_messages(event.chat_id, msgs)
                await event.edit(f"●{len(msgs)}پیام حذف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
            else:
                await event.edit("هیچ پیامی از سلف بات نیست!")
        except Exception as e:                                                              await event.edit(f"خطا: {str(e)}")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.delallmsguser$'))
    async def delete_all_user_messages(event):
        if event.sender_id != my_id:
            return
        if not event.chat_id < 0:
            await event.edit("فقط در گروه!")
            return
        if not event.is_reply:
            await event.edit("روی پیام کاربر ریپلای کنید!")
            return

        try:
            if not await check_is_admin(event.chat_id, my_id):                                  await event.edit("سلف بات ادمین نیست!")
                return

            reply = await event.get_reply_message()
            user_id = reply.sender_id

            if await check_is_admin(event.chat_id, user_id):
                await event.edit("نمی‌توانید پیام‌های ادمین را حذف کنید!")
                return

            count = 0
            async for msg in client.iter_messages(event.chat_id, from_user=user_id):
                try:
                    await client.delete_messages(event.chat_id, [msg.id])
                    count += 1
                    await asyncio.sleep(0.5)
                except:
                    pass
            await event.edit(f"●{count}پیام از کاربر حذف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
        except Exception as e:
            await event.edit(f"خطا: {str(e)}")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.delethistory$'))
    async def delete_history(event):
        if event.sender_id != my_id:
            return                                                                      if not event.chat_id < 0:
            await event.edit("فقط در گروه!")
            return

        try:
            if not await check_is_admin(event.chat_id, my_id):
                await event.edit("سلف بات ادمین نیست!")
                return

            await client(DeleteHistoryRequest(peer=event.chat_id, max_id=0, just_clear=False, revoke=True))
            await event.edit("●تاریخچه پاک شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")                             except Exception as e:
            await event.edit(f"خطا: {str(e)}")                                  
    #========= تگ همه =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.tagall\s*(.*)$'))
    async def tag_all(event):
        if event.sender_id != my_id:
            return
        if not event.chat_id < 0:
            await event.edit("فقط در گروه!")
            return

        text = event.pattern_match.group(1).strip() if event.pattern_match.group(1) else ""
        if not text and event.is_reply:                                                     reply = await event.get_reply_message()
            if reply:
                text = reply.text or "تگ همه"                                   
        if not text:
            await event.edit("متن را وارد کنید!")
            return

        await event.edit("●در حال دریافت لیست اعضا♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

        try:
            users = []
            async for user in client.iter_participants(event.chat_id):
                if not user.deleted and user.id != my_id:
                    users.append(user)

            if not users:
                await event.edit("کاربری نیست!")
                return

            msg = f"{text}\n\n"
            count = 0

            for user in users:
                if count >= 50:                                                                     await client.send_message(event.chat_id, msg)
                    msg = "ادامه:\n\n"
                    count = 0

                name = user.first_name or "کاربر"
                msg += f"[{name}](tg://user?id={user.id}) "
                count += 1

            if msg:                                                                             await client.send_message(event.chat_id, msg)

            await event.edit(f"{len(users)} کاربر تگ شد!")
        except FloodWaitError as e:
            await event.edit(f"لطفاً {e.seconds} ثانیه صبر کنید...")
        except Exception as e:
            await event.edit(f" خطا: {str(e)}")

    #========= راهنما =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.helpadmin$'))
    async def admin_help(event):
        if event.sender_id != my_id:
            return
        help_text = """راهنمای مدیریت گروه                                      
🔹 مدیریت کاربران:
┃ .ban @username - بن کردن کاربر
┃ .unban @username - رفع بن کاربر
┃ .setmute @username - سکوت کاربر
┃ .delmute @username - رفع سکوت کاربر

🔹 مدیریت ادمین‌ها:
┃ .addadmin @username - افزودن ادمین
┃ .removeadmin @username - حذف ادمین                                            ┃ .ادمین‌ها - نمایش لیست ادمین‌ها

🔹 سنجاق:
┃ .pin - سنجاق پیام (با ریپلای)
┃ .unpin - برداشتن سنجاق (با ریپلای)                                            ┃ .unpinall - حذف همه سنجاق‌ها

🔹 حذف پیام:
┃ .del - حذف پیام (با ریپلای)
┃ .delete 10 - حذف 10 پیام آخر سلف بات
┃ .delallmsguser - حذف پیام‌های یک کاربر (با ریپلای)
┃ .delethistory - پاک کردن تاریخچه گروه

🔹 تگ:
┃ .tagall متن - تگ کردن همه اعضا                                                
📌 نکته: می‌توانید به جای @username روی پیام کاربر ریپلای کنید!
"""
        await event.edit(help_text)

    # ===================== تبدیل متن به ویس فارسی با Edge TTS =====================
    @client.on(events.NewMessage(outgoing=True, pattern=r"^\.ویس (.+)$"))
    async def text_to_voice_edge(event):
        text = event.pattern_match.group(1).strip()

        if not text:
            await event.edit("❌ لطفاً متن را وارد کنید!\nمثال: .ویس سلام")
            return

        if len(text) > 500:                                                                 await event.edit("❌ متن خیلی طولانی است! (حداکثر 500 کاراکتر)")
            return

        msg = await event.edit("● در حال ساخت ویس♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡 ●")

        try:
            import edge_tts
            import os
            import time

            voice = "fa-IR-DilaraNeural"
            filename = f"voice_fa_{int(time.time())}.ogg"

            communicate = edge_tts.Communicate(text, voice)
            await communicate.save(filename)

            await msg.delete()                                                  
            await client.send_file(                                                             event.chat_id,
                filename,
                voice_note=True                                                             )

            os.remove(filename)

        except ImportError:
            await msg.edit("❌ کتابخانه edge-tts نصب نیست!\nلطفاً نصب کنید: pip install edge-tts")
        except Exception as e:
            await msg.edit(f"❌ خطا: {str(e)}")

    @client.on(events.NewMessage(outgoing=True, pattern=r"^\.ویس$"))
    async def text_to_voice_reply_edge(event):
        if not event.is_reply:
            await event.edit("❌ روی یک پیام متنی ریپلای کنید!")
            return                                                              
        reply = await event.get_reply_message()

        if not reply.text:
            await event.edit("❌ پیام ریپلای شده باید متن داشته باشد!")
            return

        text = reply.text.strip()

        if len(text) > 500:
            await event.edit("❌ متن خیلی طولانی است! (حداکثر 500 کاراکتر)")
            return

        msg = await event.edit("🎙️ درحال ساخت ویس... |Self Vidal")

        try:
            import edge_tts
            import os
            import time

            voice = "fa-IR-DilaraNeural"
            filename = f"voice_fa_reply_{int(time.time())}.ogg"

            communicate = edge_tts.Communicate(text, voice)
            await communicate.save(filename)

            await msg.delete()

            await client.send_file(
                event.chat_id,
                filename,
                voice_note=True                                                             )

            os.remove(filename)

        except ImportError:
            await msg.edit("❌ کتابخانه edge-tts نصب نیست!\nلطفاً نصب کنید: pip install edge-tts")
        except Exception as e:
            await msg.edit(f"❌ خطا: {str(e)}")
                                                                                    #========= ساخت لوگو (بدون هوش مصنوعی) =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.ساخت لوگو (.+)$'))
    async def make_logo_handler(event):
        if event.sender_id != my_id:
            return
        text = event.pattern_match.group(1).strip()
        await event.edit("●در حال ساخت لوگو♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

        try:
            width, height = 800, 400
            img = Image.new("RGB", (width, height), color=(20, 20, 30))
            draw = ImageDraw.Draw(img)

            # گرادیانت ساده پس‌زمینه
            for y in range(height):
                r = int(20 + (y / height) * 40)
                g = int(20 + (y / height) * 10)
                b = int(60 + (y / height) * 100)
                draw.line([(0, y), (width, y)], fill=(r, g, b))

            # پیدا کردن یه فونت مناسب روی سیستم
            font_path = None
            possible_fonts = [
                "/data/data/com.termux/files/usr/share/fonts/TTF/DejaVuSans-Bold.ttf",
                "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
                "/system/fonts/Roboto-Bold.ttf",
            ]                                                                   
            for p in possible_fonts:
                if os.path.exists(p):
                    font_path = p                                                                   break

            font_size = 90
            if font_path:
                font = ImageFont.truetype(font_path, font_size)
            else:
                font = ImageFont.load_default()

            # کوچیک کردن فونت اگه متن خیلی بزرگ بود
            bbox = draw.textbbox((0, 0), text, font=font)
            text_w = bbox[2] - bbox[0]
            while text_w > width - 60 and font_size > 20:
                font_size -= 5
                if font_path:
                    font = ImageFont.truetype(font_path, font_size)
                bbox = draw.textbbox((0, 0), text, font=font)
                text_w = bbox[2] - bbox[0]

            text_h = bbox[3] - bbox[1]
            x = (width - text_w) / 2
            y = (height - text_h) / 2 - bbox[1]

            # سایه
            shadow_offset = 4
            draw.text((x + shadow_offset, y + shadow_offset), text, font=font, fill=(0, 0, 0))
            # متن اصلی
            draw.text((x, y), text, font=font, fill=(255, 255, 255))            
            # خط تزئینی زیر متن
            line_y = y + text_h + 30
            draw.line([(width/2 - text_w/2, line_y), (width/2 + text_w/2, line_y)], fill=(255, 215, 0), width=4)

            output_path = f"logo_{event.id}.png"
            img.save(output_path)

            await client.send_file(event.chat_id, output_path, caption=f"لوگوی «{text}»")
            os.remove(output_path)
            await event.delete()

        except Exception as e:
            await event.edit(f"❌ خطا در ساخت لوگو: {e}")

    #========= حذف پیام (فقط در پیوی) =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.حذف پیام (\d+)$'))     async def delete_pv_messages(event):
        if event.sender_id != my_id:                                                        return
        if not event.is_private:
            await event.edit("این دستور فقط توی پیوی کار می‌کنه!")
            return                                                              
        count = int(event.pattern_match.group(1))                                       if count > 1000:
            await event.edit("حداکثر 1000 پیام در یک دستور!")
            return
                                                                                        await event.edit(f"●در حال حذف{count}پیام♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
                                                                                        try:
            msgs = []
            async for msg in client.iter_messages(event.chat_id, limit=count):
                msgs.append(msg.id)                                             
            if msgs:                                                                            # حذف دسته‌ای (تلگرام حداکثر 100 تا در هر درخواست قبول می‌کنه)
                for i in range(0, len(msgs), 100):
                    chunk = msgs[i:i+100]
                    await client.delete_messages(event.chat_id, chunk)
                    await asyncio.sleep(0.3)

                await client.send_message(event.chat_id, f"●{len(msgs)}پیام حذف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
            else:                                                                               await client.send_message(event.chat_id, "پیامی برای حذف پیدا نشد!")
        except Exception as e:
            await client.send_message(event.chat_id, f"خطا: {e}")

    #========= بازی‌ها =========

    #========= بازی تاس =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.تاس (\d+)$'))
    async def dice_game(event):
        if event.sender_id != my_id:
            return

        target = int(event.pattern_match.group(1))
        if target < 1 or target > 6:
            await event.edit("❌ عدد باید بین 1 تا 6 باشد")
            return

        await event.delete()

        while True:
            msg = await client.send_message(event.chat_id, file=types.InputMediaDice('🎲'))
            await asyncio.sleep(0.4)                                            
            if msg.media.value == target:                                                       break
            else:
                try:
                    await client.delete_messages(event.chat_id, msg.id)
                except:
                    pass


    #========= بازی بولینگ =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.بولینگ$'))             async def bowling_game(event):
        if event.sender_id != my_id:
            return

        await event.delete()

        while True:
            msg = await client.send_message(event.chat_id, file=types.InputMediaDice('🎳'))                                                                                 await asyncio.sleep(0.4)

            if msg.media.value == 6:
                break
            else:
                try:
                    await client.delete_messages(event.chat_id, msg.id)
                except:
                    pass

                                                                                    #========= بازی فوتبال =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.فوتبال$'))
    async def football_game(event):                                                     if event.sender_id != my_id:
            return
                                                                                        await event.delete()

        while True:                                                                         msg = await client.send_message(event.chat_id, file=types.InputMediaDice('⚽'))
            await asyncio.sleep(0.4)
                                                                                            if msg.media.value == 3:                                                            break
            else:
                try:                                                                                await client.delete_messages(event.chat_id, msg.id)
                except:
                    pass                                                        

    #========= بازی بسکتبال =========                                               @client.on(events.NewMessage(outgoing=True, pattern=r'^\.بسکتبال$'))
    async def basketball_game(event):
        if event.sender_id != my_id:                                                        return

        await event.delete()                                                    
        while True:
            msg = await client.send_message(event.chat_id, file=types.InputMediaDice('🏀'))
            await asyncio.sleep(0.4)
                                                                                            if msg.media.value == 4:
                break
            else:                                                                               try:
                    await client.delete_messages(event.chat_id, msg.id)
                except:                                                                             pass                                                                                                                                                                                                                            #========= بازی دارت =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.دارت$'))
    async def dart_game(event):                                                         if event.sender_id != my_id:
            return
                                                                                        await event.delete()

        while True:                                                                         msg = await client.send_message(event.chat_id, file=types.InputMediaDice('🎯'))                                                                                 await asyncio.sleep(0.4)                                                                                                                                        if msg.media.value == 6:                                                            break                                                                       else:                                                                               try:                                                                                await client.delete_messages(event.chat_id, msg.id)                         except:                                                                             pass                                                                                                                                            #========= سیستم دوست =========                                                 #========= روشن کردن دوست =========                                             @client.on(events.NewMessage(outgoing=True, pattern=r'^\.دوست روشن$'))
    async def friend_on(event):
        if event.sender_id != my_id:
            return
        global rafigh                                                                   rafigh = True
        await event.edit("●دوست روشن شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
                                                                                
    #========= خاموش کردن دوست =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.دوست خاموش$'))         async def friend_off(event):
        if event.sender_id != my_id:
            return                                                                      global rafigh                                                                   rafigh = False
        await event.edit("●دوست خاموش شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
                                                                                
    #========= تنظیم دوست =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.تنظیم دوست$'))         async def set_friend(event):                                                        if event.sender_id != my_id:                                                        return
        if not event.is_reply:
            await event.edit("باید روی پیام کاربر ریپلای بزنی")                             return

        reply = await event.get_reply_message()                                         friend_id = reply.sender_id

        if my_id not in friends_list:                                                       friends_list[my_id] = []

        if friend_id not in friends_list[my_id]:                                            friends_list[my_id].append(friend_id)

        await event.edit("●دوست اضاف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")                           
                                                                                    #========= حذف دوست =========                                                   @client.on(events.NewMessage(outgoing=True, pattern=r'^\.حذف دوست$'))
    async def del_friend(event):
        if event.sender_id != my_id:
            return
        if not event.is_reply:                                                              await event.edit("باید روی پیام کاربر ریپلای بزنی")
            return                                                                                                                                                      reply = await event.get_reply_message()                                         friend_id = reply.sender_id                                                                                                                                     if my_id in friends_list and friend_id in friends_list[my_id]:                      friends_list[my_id].remove(friend_id)                                           await event.edit("●دوست حذف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")                                else:
            await event.edit("این کاربر در لیست دوستان نیست")
                                                                                
    #========= لیست دوست =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.لیست دوست$'))
    async def list_friends(event):
        if event.sender_id != my_id:                                                        return                                                                                                                                                      if my_id not in friends_list or len(friends_list[my_id]) == 0:                      await event.edit("هیچ دوستی ثبت نشده")                                          return                                                                                                                                                      txt = "لیست دوستان:\n"
        for fid in friends_list[my_id]:
            txt += f"- `{fid}`\n"

        await event.edit(txt)                                                                                                                                                                                                                       #========= تنظیم متن =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.تنظیم متن (.+)$'))
    async def set_text(event):                                                          if event.sender_id != my_id:
            return
                                                                                        text = event.pattern_match.group(1)                                                                                                                             if my_id not in friends_texts:
            friends_texts[my_id] = []
                                                                                        friends_texts[my_id].append(text)                                               await event.edit("●متن تنظیم شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")                                                                                                                                                                                               #========= حذف متن =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.حذف متن (\d+)$'))
    async def del_text(event):                                                          if event.sender_id != my_id:                                                        return                                                                                                                                                      index = int(event.pattern_match.group(1))                               
        if my_id not in friends_texts or index >= len(friends_texts[my_id]):
            await event.edit("متن با این شماره وجود ندارد")
            return

        friends_texts[my_id].pop(index)
        await event.edit("●متن حذف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")                             
                                                                                    #========= لیست متن =========
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.لیست متن$'))           async def list_texts(event):
        if event.sender_id != my_id:
            return

        if my_id not in friends_texts or len(friends_texts[my_id]) == 0:
            await event.edit("هیچ متنی ثبت نشده")
            return                                                              
        txt = "لیست متن‌ها:\n"
        for i, t in enumerate(friends_texts[my_id]):
            txt += f"{i} ➤ {t}\n"

        await event.edit(txt)
                                                                                
    #========= پاسخ‌دهی خودکار نوبتی =========                                       @client.on(events.NewMessage(incoming=True))
    async def friend_auto(event):                                                       global rafigh
                                                                                        if my_id is None:
            return                                                                      if not rafigh:
            return                                                                      if my_id not in friends_list:
            return                                                              
        sender = event.sender_id
        if sender not in friends_list[my_id]:                                               return
        if my_id not in friends_texts or len(friends_texts[my_id]) == 0:                    return

        if sender not in friends_index:
            friends_index[sender] = 0

        texts = friends_texts[my_id]
        index = friends_index[sender]

        text = texts[index]                                                     
        friends_index[sender] += 1
        if friends_index[sender] >= len(texts):
            friends_index[sender] = 0

        await event.reply(text)                                                 
    #========= سیستم دشمن =========

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.دشمن روشن$'))
    async def enemy_on(event):
        if event.sender_id != my_id:
            return                                                                      global doshman_enabled
        doshman_enabled = True                                                          await event.edit("●دشمن روشن شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
                                                                                
    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.دشمن خاموش$'))         async def enemy_off(event):
        if event.sender_id != my_id:                                                        return
        global doshman_enabled                                                          doshman_enabled = False
        await event.edit("●دشمن خاموش شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")                          
                                                                                    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.تنظیم دشمن$'))
    async def set_enemy(event):                                                         if event.sender_id != my_id:
            return                                                                      if not event.is_reply:
            await event.edit("باید روی پیام دشمن ریپلای بزنی")                              return
                                                                                        reply = await event.get_reply_message()
        enemy_id = reply.sender_id                                              
        if my_id not in doshman_list:                                                       doshman_list[my_id] = []
                                                                                        if enemy_id not in doshman_list[my_id]:
            doshman_list[my_id].append(enemy_id)                                
        await event.edit("●دشمن اضاف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")                           

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.حذف دشمن$'))
    async def del_enemy(event):
        if event.sender_id != my_id:
            return                                                                      if not event.is_reply:
            await event.edit("باید روی پیام دشمن ریپلای بزنی")
            return

        reply = await event.get_reply_message()
        enemy_id = reply.sender_id

        if my_id in doshman_list and enemy_id in doshman_list[my_id]:
            doshman_list[my_id].remove(enemy_id)
            await event.edit("●دشمن حذف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
        else:
            await event.edit("این کاربر دشمن نیست")


    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.لیست دشمن$'))
    async def list_enemy(event):
        if event.sender_id != my_id:
            return                                                              
        if my_id not in doshman_list or len(doshman_list[my_id]) == 0:
            await event.edit("هیچ دشمنی ثبت نشده")
            return

        txt = "لیست دشمن‌ها:\n"
        for eid in doshman_list[my_id]:
            txt += f"- `{eid}`\n"

        await event.edit(txt)


    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.تنظیم فحش (.+)$'))
    async def set_enemy_text(event):
        if event.sender_id != my_id:
            return                                                              
        text = event.pattern_match.group(1)

        if my_id not in doshman_texts:
            doshman_texts[my_id] = []

        doshman_texts[my_id].append(text)
        await event.edit("●فحش تنظیم شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.حذف فحش (\d+)$'))
    async def del_enemy_text(event):
        if event.sender_id != my_id:
            return

        index = int(event.pattern_match.group(1))

        if my_id not in doshman_texts or index >= len(doshman_texts[my_id]):
            await event.edit("فحش با این شماره وجود ندارد")
            return

        doshman_texts[my_id].pop(index)
        await event.edit("●فحش حذف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.لیست فحش$'))
    async def list_enemy_texts(event):
        if event.sender_id != my_id:
            return

        if my_id not in doshman_texts or len(doshman_texts[my_id]) == 0:
            await event.edit("هیچ فحشی ثبت نشده")
            return

        txt = "لیست فحش‌ها:\n"
        for i, t in enumerate(doshman_texts[my_id]):
            txt += f"{i} ➤ {t}\n"

        await event.edit(txt)


    @client.on(events.NewMessage(incoming=True))
    async def enemy_auto(event):
        global doshman_enabled

        if my_id is None:
            return
        if not doshman_enabled:
            return
        if my_id not in doshman_list:
            return

        sender = event.sender_id
        if sender not in doshman_list[my_id]:
            return
        if my_id not in doshman_texts or len(doshman_texts[my_id]) == 0:
            return

        if sender not in doshman_index:
            doshman_index[sender] = 0

        texts = doshman_texts[my_id]
        index = doshman_index[sender]

        text = texts[index]

        doshman_index[sender] += 1
        if doshman_index[sender] >= len(texts):
            doshman_index[sender] = 0

        await event.reply(text)

    #========= سین خودکار =========

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.سین خودکار روشن$'))
    async def auto_read_on(event):
        if event.sender_id != my_id:
            return

        global auto_read_enabled
        auto_read_enabled = True

        await event.edit("●سین خودکار روشن شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")
                                                                                        try:
            dialogs = await client.get_dialogs()

            for dialog in dialogs:
                try:
                    await client.send_read_acknowledge(dialog.entity)
                    await asyncio.sleep(0.1)                                                    except Exception as e:
                    print(f"خطا در سین زدن چت {dialog.name}: {e}")

        except Exception as e:
            await event.respond(f"خطا: {e}")
                                                                                
    @client.on(events.NewMessage(incoming=True))                                    async def auto_read_new(event):
        global auto_read_enabled
        if not auto_read_enabled:
            return

        try:
            await client.send_read_acknowledge(event.chat_id)                           except Exception as e:
            print(f"خطا در سین پیام جدید: {e}")


    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.سین خودکار خاموش$'))
    async def auto_read_off(event):
        if event.sender_id != my_id:                                                        return

        global auto_read_enabled
        auto_read_enabled = False

        await event.edit("●سین خودکار خاموش شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    #========= پاسخ خودکار عمومی =========
    auto_reply_enabled = True
    auto_replies = {}  # {trigger: response}

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.تنظیم پاسخ (.+)=(.+)$'))
    async def set_auto_reply(event):
        if event.sender_id != my_id:
            return

        trigger = event.pattern_match.group(1).strip()
        response = event.pattern_match.group(2).strip()

        auto_replies[trigger] = response
        await event.edit(f"●پاسخ«{trigger}»به«{response}»تنظیم شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.لیست پاسخ$'))
    async def list_auto_replies(event):
        if event.sender_id != my_id:
            return

        if not auto_replies:
            await event.edit("هیچ پاسخی تنظیم نشده")
            return

        text = "لیست پاسخ‌ها:\n\n"
        for i, (trigger, response) in enumerate(auto_replies.items(), start=1):
            text += f"{i}. {trigger} → {response}\n"

        await event.edit(text)

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.حذف پاسخ (\d+)$'))
    async def delete_auto_reply(event):
        if event.sender_id != my_id:
            return

        index = int(event.pattern_match.group(1))

        if index < 1 or index > len(auto_replies):
            await event.edit("همچین آیدی پاسخی وجود نداره")
            return

        key = list(auto_replies.keys())[index - 1]
        del auto_replies[key]

        await event.edit(f"●پاسخ شماره{index}حذف شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.پاسخ روشن$'))
    async def enable_auto_reply(event):
        if event.sender_id != my_id:
            return

        global auto_reply_enabled
        auto_reply_enabled = True
        await event.edit("●پاسخ خودکار روشن شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(outgoing=True, pattern=r'^\.پاسخ خاموش$'))
    async def disable_auto_reply(event):
        if event.sender_id != my_id:
            return

        global auto_reply_enabled
        auto_reply_enabled = False
        await event.edit("●پاسخ خودکار خاموش شد♕𝙎𝙀𝙇𝙁 𝙑𝙞𝙙𝙖𝙡●")

    @client.on(events.NewMessage(incoming=True))
    async def auto_reply_handler(event):
        if not auto_reply_enabled:
            return

        if event.sender_id == my_id:
            return

        text = event.raw_text.strip()

        for trigger, response in auto_replies.items():
            if text == trigger:
                try:
                    await event.reply(response)
                except:
                    pass
                break

    # پایان setup_reactions
    return