import asyncio

from html import escape
from pyrogram.types import CallbackQuery, ReplyParameters, LinkPreviewOptions, InlineKeyboardMarkup, InlineKeyboardButton

import app

from app.config import ADMINS
from app.handlers.buttons import Buttons

class CallbackQueryHandler:
    async def callback_query_handler(self: "app.App", _, callback_query: CallbackQuery):
        user_id = callback_query.from_user.id

        if self.setting.off and user_id not in ADMINS:
            return await callback_query.answer("⭕️ ربات در حال حاضر خاموش است.", show_alert=True)
        
        elif await self.database.get_block(user_id):
            return await callback_query.answer("🚫 شما از گسترده مسدود شده اید.", show_alert=True)
        
        get_user = await self.database.get_user(user_id=user_id)
        
        get_arguments = callback_query.data.split("|")
        
        if get_arguments[0] == "support":
            return await callback_query.answer("🪵 روی پیام ریپلی بزنید.", show_alert=True)
        
        elif get_arguments[0] == "none":
            return await callback_query.answer("🪵 این پیام نمایشی است.", show_alert=True)
            
        elif get_arguments[0] == "register":
            get_register = await self.database.get_register(user_id=int(get_arguments[2]), verify=False)
            
            if not get_register:
                return await callback_query.edit_message_text(
                    text="🐋 این درخواست دیگر وجود ندارد."
                )
                
            if get_arguments[1] == "cancel":
                try:
                    await self.client.send_message(
                        chat_id=get_register.user_id,
                        text="🔴 درخواست ثبت نام شما توسط ادمین رد شد."
                    )
                except:
                    pass
                
                await self.database.delete_register(get_register.user_id)
                await callback_query.edit_message_text(
                    text="🐋 درخواست ثبت نام این کاربر رد شد."
                )
            else:
                get_arg_user = await self.database.get_user(user_id=get_register.user_id)
                await self.database.update_user(get_arg_user, verify=True, step=None)
                
                try:
                    await self.client.send_message(
                        chat_id=get_register.user_id,
                        text="🟢 درخواست ثبت نام شما توسط ادمین تایید شد.",
                        reply_markup=Buttons.home
                    )
                except:
                    pass
                
                await self.database.delete_register(get_register.user_id)
                await callback_query.edit_message_text(
                    text="🐋 درخواست ثبت نام این کاربر تایید شد."
                )

        elif get_arguments[0] == "admin_message":
            try:
                get_users = await self.client.get_users(int(get_arguments[1]))
                full_name = get_users.full_name
            except:
                full_name = get_arguments[1]
                    
            await self.database.update_user(get_user, step=f"admin_message|{int(get_arguments[1])}")
            await callback_query.message.reply(
                text=f"🪶 متن خود را برای ارسال پیام به کاربر {full_name} وارد کنید.",
                reply_markup=Buttons.back,
                reply_parameters=ReplyParameters(message_id=callback_query.message.id)
            )

        elif get_arguments[0] == "channels":
            if not await self.database.get_channels_count(user_id=user_id, verify=True):
                return await callback_query.edit_message_text(
                    text='🗄 شما در حال حاضر <b>کانالی</b> برای نمایش ندارید، از طریق دکمه ی <b>اضافه کردن کانال</b> اقدام به <b>اضافه کردن</b> آن کنید.'
                )
                
            buttons = []
            channel_numbers = await self.database.get_channels_count(user_id=user_id, verify=True)
            number = 0

            async for channel in self.database.get_channels(user_id=user_id, verify=True):
                if channel_numbers > 10:
                    await asyncio.sleep(0.05)

                try:
                    get_chat = await self.client.get_chat(channel.chat_id)
                    title = get_chat.title
                except:
                    number += 1
                    title = f"کانال {number}"
                    
                buttons.append([
                    InlineKeyboardButton(title, callback_data=f"channel|{channel.tag}")
                ])
            
            markup = InlineKeyboardMarkup(buttons)

            await callback_query.edit_message_text(
                text='🗄 لیست <b>کانال</b> های شما به شرح زیر می باشد، جهت <b>مدیریت</b> روی آن ضربه بزنید:',
                reply_markup=markup
            )


        elif get_arguments[0] == "channel":
            get_channel = await self.database.get_channel(tag=get_arguments[1])
            
            if not get_channel:
                return await callback_query.answer("🗄 این کانال دیگر وجود ندارد.", True)
            
        
            markup = InlineKeyboardMarkup(
                [
                    [
                        InlineKeyboardButton(text='❌ حذف', callback_data=f"delete_channel|{get_channel.tag}|normal")
                    ],
                    [
                        InlineKeyboardButton(text='🔙 بازگشت', callback_data="channels"),
                    ]
                ]
            )

            try:
                get_chat = await self.client.get_chat(get_channel.chat_id)
                title = get_chat.title
                members = f"📊 عضو ها: <b>{await get_chat.members_count:,}</b>"
            except:
                title = "-"
                members = ""

            await callback_query.edit_message_text(
                text=f"""🗄 مشخصات کانال شما به شرح زیر می باشد:

💡 آیدی کانال: <code>{get_channel.chat_id}</code>
🧾 نام کانال: <b>{escape(title)}</b>
🔖 نوع کانال: <b>{self.channel_type(get_channel.channel_type)}</b>
{members}""",
                reply_markup=markup
            )
                
        elif get_arguments[0] == "delete_channel":
            get_channel = await self.database.get_channel(tag=get_arguments[1])
            
            if not get_channel:
                return await callback_query.answer("🗄 این کانال دیگر وجود ندارد.", True)
            
            elif get_arguments[2] != "verify":
                markup = InlineKeyboardMarkup(
                    [
                        [
                            InlineKeyboardButton(text='❌ لغو', callback_data=f"channel|{get_channel.tag}")
                        ],
                        [
                            InlineKeyboardButton(text='✅ تایید', callback_data=f"delete_channel|{get_channel.tag}|verify")
                        ]
                    ]
                )

                try:
                    get_chat = await self.client.get_chat(get_channel.chat_id)
                    title = get_chat.title
                except:
                    title = get_channel.chat_id

                await callback_query.edit_message_text(
                    text=f'🗄 آیا از حذف کانال <b>{title}</b> اطمینان دارید؟',
                    reply_markup=markup
                )
            else:
                async for seen in self.database.get_seens(chat_id=get_channel.chat_id):
                    await self.database.delete_seen(seen.id)

                await self.database.delete_channel(get_channel.tag)

                if not await self.database.get_channels_count(user_id=user_id, verify=True):
                    return await callback_query.edit_message_text(
                        text='🗄 شما در حال حاضر <b>کانالی</b> برای نمایش ندارید، از طریق دکمه ی <b>اضافه کردن کانال</b> اقدام به <b>اضافه کردن</b> آن کنید.'
                    )
                else:
                    buttons = []
                    channel_numbers = await self.database.get_channels_count(user_id=user_id, verify=True)
                    number = 0

                    async for channel in self.database.get_channels(user_id=user_id, verify=True):
                        if channel_numbers > 10:
                            await asyncio.sleep(0.05)

                        try:
                            get_chat = await self.client.get_chat(channel.chat_id)
                            title = get_chat.title
                        except:
                            number += 1
                            title = f"کانال {number}"
                            
                        buttons.append([
                            InlineKeyboardButton(title, callback_data=f"channel|{channel.tag}")
                        ])
                    
                    markup = InlineKeyboardMarkup(buttons)

                    await callback_query.edit_message_text(
                        text='🗄 لیست <b>کانال</b> های شما به شرح زیر می باشد، جهت <b>مدیریت</b> روی آن ضربه بزنید:',
                        reply_markup=markup
                    )
                
        elif get_arguments[0] == "admin_delete_channel":
            get_channel = await self.database.get_channel(tag=get_arguments[1])
            
            if not get_channel:
                return await callback_query.answer("🗄 این کانال دیگر وجود ندارد.", True)
            
            elif get_arguments[2] == "normal":
                markup = InlineKeyboardMarkup(
                    [
                        [
                            InlineKeyboardButton(text='❌ لغو', callback_data=f"admin_delete_channel|{get_channel.tag}|cancel")
                        ],
                        [
                            InlineKeyboardButton(text='✅ تایید', callback_data=f"admin_delete_channel|{get_channel.tag}|verify")
                        ]
                    ]
                )

                try:
                    get_chat = await self.client.get_chat(get_channel.chat_id)
                    title = get_chat.title
                except:
                    title = get_channel.chat_id

                await callback_query.edit_message_text(
                    text=f'🗄 آیا از حذف کانال <b>{title}</b> اطمینان دارید؟',
                    reply_markup=markup
                )
            
            elif get_arguments[2] == "cancel":
                markup = InlineKeyboardMarkup(
                    [
                        [
                            InlineKeyboardButton(text='❌ حذف', callback_data=f"admin_delete_channel|{get_channel.tag}|normal")
                        ]
                    ]
                )
                    
                try:
                    get_chat = await self.client.get_chat(get_channel.chat_id)
                    title = get_chat.title
                    link = await self.client.export_chat_invite_link(get_channel.chat_id)
                except:
                    title = "-"
                    link = "-"

                await callback_query.edit_message_text(
                    text=f"💡 آیدی کانال: <code>{get_channel.chat_id}</code>\n🧾 نام کانال: <b>{escape(title)}</b>\n🔗 لینک کانال: {link}\n🔖 نوع کانال: <b>{self.channel_type(get_channel.channel_type)}</b>",
                    reply_markup=markup
                )
            else:
                try:
                    get_chat = await self.client.get_chat(get_channel.chat_id)
                    title = get_chat.title
                except:
                    title = get_channel.chat_id

                try:
                    await self.client.send_message(
                        chat_id=get_channel.user_id,
                        text=f"🗄 کانال <b>{title}</b> توسط مدیر حذف شد."
                    )
                except:
                    pass

                async for seen in self.database.get_seens(chat_id=get_channel.chat_id):
                    await self.database.delete_seen(seen.id)
                    
                await self.database.delete_channel(get_channel.tag)

                await callback_query.edit_message_text(
                    text=f'🗄 کانال <b>{title}</b> با موفقیت حذف شد'
                )
                
                
        elif get_arguments[0] == "admin_delete_seen":
            get_seen = await self.database.get_seen(tag=get_arguments[1])
            
            if not get_seen:
                return await callback_query.answer("🗄 این بنر دیگر وجود ندارد.", True)
            
            elif get_arguments[2] == "normal":
                markup = InlineKeyboardMarkup(
                    [
                        [
                            InlineKeyboardButton(text='❌ لغو', callback_data=f"admin_delete_seen|{get_seen.tag}|cancel")
                        ],
                        [
                            InlineKeyboardButton(text='✅ تایید', callback_data=f"admin_delete_seen|{get_seen.tag}|verify")
                        ]
                    ]
                )

                try:
                    get_chat = await self.client.get_chat(get_seen.chat_id)
                    title = get_chat.title
                except:
                    title = get_seen.chat_id

                await callback_query.edit_message_text(
                    text=f'🗄 آیا از حذف بنر <b>{title}</b> اطمینان دارید؟',
                    reply_markup=markup
                )
            
            elif get_arguments[2] == "cancel":
                markup = InlineKeyboardMarkup(
                    [
                        [
                            InlineKeyboardButton(text='❌ حذف بنر', callback_data=f"admin_delete_seen|{get_seen.tag}|normal")
                        ]
                    ]
                )
                    
                try:
                    get_chat = await self.client.get_chat(get_seen.chat_id)
                    title = get_chat.title
                    link = await self.client.export_chat_invite_link(get_seen.chat_id)
                except:
                    title = "-"
                    link = "-"

                await callback_query.edit_message_text(
                    text=f"💡 آیدی کانال: <code>{get_seen.chat_id}</code>\n🧾 نام کانال: <b>{escape(title)}</b>\n🔗 لینک کانال: {link}\n\n➰ سین: <b>{get_seen.all_count + get_seen.count:,}</b>\n➰ سین کل: <b>{await self.database.get_all_seens_count(chat_id=get_seen.chat_id):,}</b>",
                    reply_markup=markup
                )
            else:
                try:
                    get_chat = await self.client.get_chat(get_seen.chat_id)
                    title = get_chat.title
                except:
                    title = get_seen.chat_id

                async for seen in self.database.get_seens(chat_id=get_seen.chat_id, banner_tag=get_seen.banner_tag):
                    if seen.tag == get_seen.tag:
                        continue
                    
                    await self.database.update_seen(seen, all_count=seen.all_count + get_seen.all_count + get_seen.count)
                    
                    break
                
                await self.database.delete_seen(get_seen.id)

                await callback_query.edit_message_text(
                    text=f'🗄 بنر <b>{title}</b> با موفقیت حذف شد'
                )
                
        elif get_arguments[0] == "add_channel":
            get_channel = await self.database.get_channel(tag=get_arguments[2])
            
            if not get_channel:
                return await callback_query.answer("🗄 این کانال دیگر وجود ندارد.", True)
            
            elif get_channel.verify:
                return await callback_query.answer("🗄 این کانال تایید شده است.", True)

            try:
                get_chat = await self.client.get_chat(get_channel.chat_id)
                title = get_chat.title
            except:
                title = get_channel.chat_id

            if get_arguments[1] == "cancel":
                try:
                    await self.client.send_message(
                        chat_id=get_channel.user_id,
                        text=f"🔴 درخواست اضافه کردن کانال <b>{title}</b> توسط مدیر رد شد."
                    )
                except Exception as e:
                    print(e)
                    pass
                
                await self.database.delete_channel(get_channel.tag)
                await callback_query.answer("🔴 درخواست کانال این کاربر رد شد.")
                await callback_query.edit_message_reply_markup(
                    reply_markup=None
                )
            else:
                try:
                    await self.client.send_message(
                        chat_id=get_channel.user_id,
                        text=f"🟢 درخواست اضافه کردن کانال <b>{title}</b> توسط مدیر تایید شد."
                    )
                except Exception as e:
                    print(e)
                    pass
                
                await self.database.update_channel(get_channel, verify=True)
                await callback_query.answer("🟢 درخواست کانال این کاربر تایید شد.")
                await callback_query.edit_message_reply_markup(
                    reply_markup=None
                )
        elif get_arguments[0] == "right":
            get_admin = await self.database.get_admin(user_id=int(get_arguments[2]))
            
            if not get_admin:
                await callback_query.answer("این کاربر مدیر نیست.", True)
                return await callback_query.message.delete()
            
            rights = self.decode(get_admin.rights)
            
            if get_arguments[1] not in rights:
                rights.append(get_arguments[1])
            else:
                rights.remove(get_arguments[1])
                
            await self.database.update_admin(get_admin, rights=self.encode(rights))

            rights_list = {
                "statistic": "📊 آمار",
                "send_all": "🔖 ارسال همگانی",
                "send_user_pm": "✉️ پیام به کاربر",
                "edit_balance": "💵 افزایش موجودی",
                "banner": "⭐️ بنر",
                "invoices": "✨ تسویه ها",
                "user_info": "👤 مشخصات کاربر",
                "users": "🌵 کاربران",
                "ban_user": "🍁 اخراج کاربر",
                "extract": "📮 استخراج",
                "support": "🧑🏻‍💻 پشتیبانی",
                "bot_settings": "🤖 تنظیمات ربات"
            }
            
            buttons = []
            for right_key, right_name in rights_list.items():
                if right_key in rights:
                    emoji = "✅"
                else:
                    emoji = "❌"
                    
                buttons.append([InlineKeyboardButton(emoji, callback_data=f"right|{right_key}|{get_admin.user_id}"), InlineKeyboardButton(right_name, callback_data=f"right|{right_key}|{get_admin.user_id}")])
            
            buttons.append([
                InlineKeyboardButton("🔙 بازگشت به پنل", callback_data="back_to_admin_panel")
            ])
            
            markup = InlineKeyboardMarkup(buttons)
            
            await callback_query.message.edit_reply_markup(
                reply_markup=markup
            )

        elif get_arguments[0] == "bot_settings":
            bot_settings_keyboard = InlineKeyboardMarkup([
                [
                    InlineKeyboardButton("💰 تنظیمات مالی", callback_data="settings_finance"),
                    InlineKeyboardButton("📢 تنظیمات کانال‌ها", callback_data="settings_channels")
                ],
                [
                    InlineKeyboardButton("💾 تنظیمات بکاپ", callback_data="settings_backup"),
                    InlineKeyboardButton("⚙️ تنظیمات عمومی", callback_data="settings_general")
                ],
                [
                    InlineKeyboardButton("📝 متن‌ها و پیام‌ها", callback_data="settings_texts"),
                    InlineKeyboardButton("📌 گروه ثبت‌نام", callback_data="settings_register_group")
                ],
                [
                    InlineKeyboardButton("🔄 ریست دیتابیس", callback_data="settings_reset_db"),
                    InlineKeyboardButton("📊 آمار ربات", callback_data="settings_stats")
                ],
                [
                    InlineKeyboardButton("🔁 ریاستارت", callback_data="settings_restart"),
                    InlineKeyboardButton("🔙 بازگشت به پنل", callback_data="back_to_admin_panel")
                ]
            ])
            
            await callback_query.message.edit_text(
                text="🤖 **تنظیمات ربات**\n\nلطفاً یکی از گزینه‌های زیر را انتخاب کنید:",
                reply_markup=bot_settings_keyboard
            )

        elif get_arguments[0] == "settings_finance":
            await callback_query.answer("💰 تنظیمات مالی - در حال توسعه", show_alert=True)
            await callback_query.message.edit_text(
                text="💰 **تنظیمات مالی**\n\n"
                     "🔹 این بخش در حال توسعه است.\n"
                     "🔹 به زودی امکان مدیریت نرخ‌ها و برداشت اضافه می‌شود.",
                reply_markup=InlineKeyboardMarkup([
                    [InlineKeyboardButton("🔙 بازگشت", callback_data="bot_settings")]
                ])
            )

        elif get_arguments[0] == "settings_channels":
            await callback_query.answer("📢 تنظیمات کانال‌ها - در حال توسعه", show_alert=True)
            await callback_query.message.edit_text(
                text="📢 **تنظیمات کانال‌ها**\n\n"
                     "🔹 این بخش در حال توسعه است.\n"
                     "🔹 به زودی امکان مدیریت کانال‌های ربات اضافه می‌شود.",
                reply_markup=InlineKeyboardMarkup([
                    [InlineKeyboardButton("🔙 بازگشت", callback_data="bot_settings")]
                ])
            )

        elif get_arguments[0] == "settings_backup":
            await callback_query.answer("💾 تنظیمات بکاپ - در حال توسعه", show_alert=True)
            await callback_query.message.edit_text(
                text="💾 **تنظیمات بکاپ**\n\n"
                     "🔹 این بخش در حال توسعه است.\n"
                     "🔹 به زودی امکان مدیریت پشتیبان‌گیری اضافه می‌شود.",
                reply_markup=InlineKeyboardMarkup([
                    [InlineKeyboardButton("🔙 بازگشت", callback_data="bot_settings")]
                ])
            )

        elif get_arguments[0] == "settings_general":
            await callback_query.answer("⚙️ تنظیمات عمومی - در حال توسعه", show_alert=True)
            await callback_query.message.edit_text(
                text="⚙️ **تنظیمات عمومی**\n\n"
                     "🔹 این بخش در حال توسعه است.\n"
                     "🔹 به زودی امکان مدیریت تنظیمات اصلی ربات اضافه می‌شود.",
                reply_markup=InlineKeyboardMarkup([
                    [InlineKeyboardButton("🔙 بازگشت", callback_data="bot_settings")]
                ])
            )

        elif get_arguments[0] == "settings_texts":
            await callback_query.answer("📝 متن‌ها و پیام‌ها - در حال توسعه", show_alert=True)
            await callback_query.message.edit_text(
                text="📝 **متن‌ها و پیام‌ها**\n\n"
                     "🔹 این بخش در حال توسعه است.\n"
                     "🔹 به زودی امکان ویرایش پیام‌های ربات اضافه می‌شود.",
                reply_markup=InlineKeyboardMarkup([
                    [InlineKeyboardButton("🔙 بازگشت", callback_data="bot_settings")]
                ])
            )

        elif get_arguments[0] == "settings_reset_db":
            reset_keyboard = InlineKeyboardMarkup([
                [
                    InlineKeyboardButton("✅ بله، ریست کن", callback_data="confirm_reset_db"),
                    InlineKeyboardButton("❌ انصراف", callback_data="bot_settings")
                ]
            ])
            
            await callback_query.message.edit_text(
                text="⚠️ **هشدار!**\n\n"
                     "آیا از ریست کردن دیتابیس اطمینان دارید؟\n\n"
                     "❌ این عمل **غیرقابل بازگشت** است!\n"
                     "🔹 تمام کاربران، بنرها، برداشت‌ها و تنظیمات پاک می‌شوند.",
                reply_markup=reset_keyboard
            )

        elif get_arguments[0] == "confirm_reset_db":
            await callback_query.answer("🔄 در حال ریست دیتابیس...", show_alert=True)
            
            try:
                from sqlalchemy import text
                from app.database import Base
                
                async with self.database.engine.begin() as conn:
                    tables = await conn.execute(
                        text("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
                    )
                    tables = [row[0] for row in tables]
                    
                    await conn.execute(text("PRAGMA foreign_keys = OFF"))
                    for table in tables:
                        await conn.execute(text(f"DROP TABLE IF EXISTS {table}"))
                    await conn.execute(text("PRAGMA foreign_keys = ON"))
                
                async with self.database.engine.begin() as conn:
                    await conn.run_sync(Base.metadata.create_all)
                
                await callback_query.message.edit_text(
                    text="✅ **دیتابیس با موفقیت ریست شد!**\n\n"
                         "همه داده‌ها پاک شدند و ربات از صفر شروع به کار می‌کند.",
                    reply_markup=InlineKeyboardMarkup([
                        [InlineKeyboardButton("🔙 بازگشت", callback_data="bot_settings")]
                    ])
                )
            except Exception as e:
                await callback_query.message.edit_text(
                    text=f"❌ خطا در ریست دیتابیس:\n\n<code>{e}</code>",
                    reply_markup=InlineKeyboardMarkup([
                        [InlineKeyboardButton("🔙 بازگشت", callback_data="bot_settings")]
                    ])
                )

        elif get_arguments[0] == "settings_stats":
            await callback_query.answer("📊 در حال بارگذاری آمار...")
            
            users_count = await self.database.get_users_count()
            active_15m = await self.database.get_last_use_users(self.timestamp - 900)
            banners_active = await self.database.get_banners_count(status=0)
            all_seens = await self.database.get_all_seens_count()
            current_balance = await self.database.get_users_current_balance()
            
            stats_text = (
                "📊 **آمار ربات**\n"
                "━━━━━━━━━━━━━━━━━━━━━━\n\n"
                f"👤 کل کاربران: <code>{users_count:,}</code>\n"
                f"⏱ فعالان ۱۵ دقیقه: <code>{active_15m:,}</code>\n"
                f"📢 بنرهای فعال: <code>{banners_active:,}</code>\n"
                f"👁 کل سین‌ها: <code>{all_seens:,}</code>\n"
                f"💰 موجودی کل کاربران: <code>{current_balance:,}</code> تومان\n"
            )
            
            await callback_query.message.edit_text(
                text=stats_text,
                reply_markup=InlineKeyboardMarkup([
                    [InlineKeyboardButton("🔙 بازگشت", callback_data="bot_settings")]
                ])
            )

        elif get_arguments[0] == "settings_restart":
            await callback_query.answer("🔄 در حال ریاستارت ربات...", show_alert=True)
            await callback_query.message.edit_text(
                text="🔄 **در حال ریاستارت ربات...**\n\nلطفاً چند ثانیه صبر کنید.",
                reply_markup=None
            )
            
            import os
            import sys
            os.execl(sys.executable, sys.executable, *sys.argv)

        elif get_arguments[0] == "settings_register_group":
            register_group_keyboard = InlineKeyboardMarkup([
                [
                    InlineKeyboardButton("📌 تنظیم گروه جدید", callback_data="set_register_group"),
                    InlineKeyboardButton("🗑️ حذف گروه", callback_data="clear_register_group")
                ],
                [
                    InlineKeyboardButton("🔙 بازگشت", callback_data="bot_settings")
                ]
            ])
            
            current_group = self.setting.register_group or "تنظیم نشده"
            
            await callback_query.message.edit_text(
                text=f"📌 **تنظیمات گروه ثبت‌نام**\n\n"
                     "🔹 درخواست‌های ثبت‌نام کاربران به این گروه ارسال می‌شود.\n\n"
                     f"📌 **گروه فعلی:** <code>{current_group}</code>\n\n"
                     "⚠️ ربات باید در گروه **ادمین** باشد.\n\n"
                     "🔹 برای تغییر، روی دکمه **تنظیم گروه جدید** کلیک کنید.",
                reply_markup=register_group_keyboard
            )

        elif get_arguments[0] == "set_register_group":
            await self.database.update_user(get_user, step="set_register_group")
            await callback_query.answer()
            await callback_query.message.reply(
                text="📌 **لطفاً آیدی عددی گروه را ارسال کنید:**\n\n"
                     "⚠️ ربات باید در گروه **ادمین** باشد.\n\n"
                     "📌 مثال: <code>-1001234567890</code>",
                reply_markup=Buttons.back,
                quote=True
            )

        elif get_arguments[0] == "clear_register_group":
            await self.database.update_setting(self.setting, register_group=0)
            await callback_query.answer("✅ گروه ثبت‌نام با موفقیت حذف شد!", show_alert=True)
            
            register_group_keyboard = InlineKeyboardMarkup([
                [
                    InlineKeyboardButton("📌 تنظیم گروه جدید", callback_data="set_register_group"),
                    InlineKeyboardButton("🗑️ حذف گروه", callback_data="clear_register_group")
                ],
                [
                    InlineKeyboardButton("🔙 بازگشت", callback_data="bot_settings")
                ]
            ])
            
            await callback_query.message.edit_text(
                text=f"📌 **تنظیمات گروه ثبت‌نام**\n\n"
                     "🔹 درخواست‌های ثبت‌نام کاربران به این گروه ارسال می‌شود.\n\n"
                     f"📌 **گروه فعلی:** <code>تنظیم نشده</code>\n\n"
                     "⚠️ ربات باید در گروه **ادمین** باشد.\n\n"
                     "🔹 برای تنظیم، روی دکمه **تنظیم گروه جدید** کلیک کنید.",
                reply_markup=register_group_keyboard
            )

        elif get_arguments[0] == "back_to_admin_panel":
            admin_markup = Buttons.admin(callback_query.from_user.id, await self.admin_rights(callback_query.from_user.id))
            await callback_query.message.edit_text(
                text="☁️ به پنل مدیریت خوش آمدید.",
                reply_markup=admin_markup
            )
            
        elif get_arguments[0] == "withdraw":
            get_withdraw = await self.database.get_withdraw(user_id=int(get_arguments[2]))
            
            if not get_withdraw:
                return await callback_query.edit_message_text(
                    text="💳 این درخواست دیگر وجود ندارد."
                )
                
            get_arg_user = await self.database.get_user(user_id=get_withdraw.user_id)
            
            if get_arguments[1] == "cancel":
                try:
                    await self.client.send_message(
                        chat_id=get_withdraw.user_id,
                        text="🔴 درخواست برداشت موجودی شما توسط ادمین رد شد."
                    )
                except:
                    pass
                
                await callback_query.edit_message_text(
                    text="💳 درخواست برداشت این کاربر رد شد."
                )
                
                await self.database.delete_withdraw(get_withdraw.id)
            else:
                await callback_query.edit_message_reply_markup(
                    reply_markup=None
                )
                
                try:
                    get_users = await self.client.get_users(get_withdraw.user_id)
                    full_name = get_users.full_name
                except:
                    full_name = get_withdraw.user_id
                
                if get_withdraw.type == "bank":
                    await self.database.update_user(get_user, step=f"screenshot|{get_withdraw.user_id}")
                    await callback_query.message.reply(
                        text=f"🪶 عکس واریزی خود را برای ارسال فیش به کاربر {full_name} وارد کنید.",
                        reply_markup=Buttons.back,
                        reply_parameters=ReplyParameters(message_id=callback_query.message.id)
                    )
                else:
                    await self.database.update_user(get_user, step=f"wallet_hash|{get_withdraw.user_id}")
                    await callback_query.message.reply(
                        text=f"🪶 فیش واریزی خود را برای ارسال فیش به کاربر {full_name} وارد کنید.",
                        reply_markup=Buttons.back,
                        reply_parameters=ReplyParameters(message_id=callback_query.message.id)
                    )
            
        elif get_arguments[0] == "banner":
            get_banner = await self.database.get_banner(tag=get_arguments[1], status=0)
            
            if not get_banner:
                return await callback_query.answer("🪵 این بنر دیگر وجود ندارد.", True)
            
            if get_banner.banner_limit == 0:
                banner_limit = "نامحدود"
            else:
                banner_limit = f"{get_banner.banner_limit:,}"
            
            get_seens = await self.database.get_all_seens_count(banner_tag=get_banner.tag)

            if get_banner.banner_end == 1:
                banner_count = f"➿ ظرفیت: <b>{get_banner.count:,}</b>"
                banner_left = f"<b>{get_banner.count - get_seens:,}</b>"
            else:
                banner_count = f"🕐 زمان: <b>{get_banner.count:,} روز</b>"
                banner_left = f"<b>{(get_banner.count - (self.timestamp - get_banner.date) // 86400):,} روز</b>"
                    
            if get_banner.banner_limit == 0 or get_seens < get_banner.banner_limit:
                status = "✅"
            else:
                status = "❌"
                    
            markup = InlineKeyboardMarkup(
                [
                    [
                        InlineKeyboardButton("🔄 بروزرسانی", callback_data=f"banner|{get_banner.tag}|refresh")
                    ],
                    [
                        InlineKeyboardButton("آمار 📊", callback_data=f"statistic|{get_banner.tag}"),
                        InlineKeyboardButton("🔗 دریافت بنر", callback_data=f"rec_banner|{get_banner.tag}|NOTHING|normal")
                    ],
                    [
                        InlineKeyboardButton("🔙 بازگشت", callback_data="enable_banners")
                    ]
                ]
            )
            
            try:
                if get_arguments[2] == "refresh":
                    await callback_query.edit_message_text(
                        text=f"""💡 مشخصات بنر به شرح زیر می باشد:

🕯 نام: <b>{escape(get_banner.banner_name)}</b>

🌀 محدودیت بنر: <b>{banner_limit}</b>
🔖 نوع کانال: <b>{' - '.join(list(map(lambda x: self.channel_type(x), self.decode(get_banner.channel_type))))}</b>

{banner_count}
✔️ سین کل: <b>{get_seens:,}</b>
〰️ باقی مانده: {banner_left}

💵 نرخ 1000 سین: <b>{get_banner.s1000:,} تومان</b>
💰 درآمد کل: <b>{round((get_seens / 1000) * get_banner.s1000):,} تومان</b>

⚜️ قابل دریافت: {status}
📆 تاریخ ساخت: <b>{self.jalali_date(get_banner.date)}</b>

〽️ توضیحات: <b>{get_banner.description}</b>

🤖 <b>@{self.client.me.username}</b>""",
                        reply_markup=markup
                    )
                else:
                    sent_messaage = await self.client.forward_messages(
                        from_chat_id=self.setting.banner_channel,
                        chat_id=user_id,
                        message_ids=get_banner.msg_id
                    )

                    await sent_messaage.reply(
                        text=f"""💡 مشخصات بنر به شرح زیر می باشد:

🕯 نام: <b>{escape(get_banner.banner_name)}</b>

🌀 محدودیت بنر: <b>{banner_limit}</b>
🔖 نوع کانال: <b>{' - '.join(list(map(lambda x: self.channel_type(x), self.decode(get_banner.channel_type))))}</b>

{banner_count}
✔️ سین کل: <b>{get_seens:,}</b>
〰️ باقی مانده: {banner_left}

💵 نرخ 1000 سین: <b>{get_banner.s1000:,} تومان</b>
💰 درآمد کل: <b>{round((get_seens / 1000) * get_banner.s1000):,} تومان</b>

⚜️ قابل دریافت: {status}
📆 تاریخ ساخت: <b>{self.jalali_date(get_banner.date)}</b>

〽️ توضیحات: <b>{get_banner.description}</b>

🤖 <b>@{self.client.me.username}</b>""",
                        reply_markup=markup,
                        reply_parameters=ReplyParameters(message_id=sent_messaage.id)
                    )
            except:
                if get_arguments[2] == "refresh":
                    await callback_query.answer("🔄 این بنر درحال حاضر بروز می باشد.", True)
            
        elif get_arguments[0] == "statistic":
            get_banner = await self.database.get_banner(tag=get_arguments[1], status=0)
            
            if not get_banner:
                return await callback_query.answer("🪵 این بنر دیگر وجود ندارد.", True)
            
            try:
                get_chat = await self.client.get_chat(get_banner.chat_id)
                channel_title = get_chat.title
            except:
                channel_title = "ناشناس"
                
            text = ""
            rank = 0
            
            async for user_id, total_count in self.database.get_banner_ranks(get_banner.tag):
                if rank >= 10:
                    break
                
                rank += 1
                
                try:
                    get_users = await self.client.get_users(user_id)
                    full_name = get_users.full_name
                except:
                    full_name = user_id

                text += f"""📈 رتبه: <b>{rank}</b>
👤 نام کاربر: <b>{full_name}</b>
〰️ تعداد سین ها: <b>{total_count:,}</b>
💵 درآمد: <b>{round((total_count / 1000) * get_banner.s1000):,} تومان</b>\n\n"""
            
            markup = InlineKeyboardMarkup(
                [
                    [
                        InlineKeyboardButton("🔙 بازگشت", callback_data=f"banner|{get_banner.tag}|refresh")
                    ]
                ]
            )
                    
            await callback_query.edit_message_text(
                text=f"""💡 آمار بنر <b>{channel_title}</b> به شرح زیر می باشد:
                
{text}🤖 <b>@{self.client.me.username}</b>""",
                reply_markup=markup,
                disable_web_page_preview=LinkPreviewOptions(is_disabled=True)
            )
            
        elif get_arguments[0] == "enable_banners":
            if not await self.database.get_banners_count(status=0):
                return await callback_query.edit_message_text(
                    text="💡 درحال حاضر هیچ بنر فعالی موجود نمی باشد."
                )
                
            buttons = []
        
            async for banner in self.database.get_banners(status=0):
                buttons.append(
                    [
                        InlineKeyboardButton(banner.banner_name, callback_data=f"banner|{banner.tag}|normal")
                    ]
                )
        
            markup = InlineKeyboardMarkup(buttons)
        
            await callback_query.edit_message_text(
                text="💡 بنر های فعال به شرح زیر می باشد، برای دریافت یا مشاهده ی جزئیات روی آنها کلیک کنید.",
                reply_markup=markup
            )
            
        elif get_arguments[0] == "rec_banner":
            get_banner = await self.database.get_banner(tag=get_arguments[1], status=0)
            
            if not get_banner:
                return await callback_query.answer("🪵 این بنر دیگر وجود ندارد.", True)
            
            elif get_banner.banner_limit != 0 and await self.database.get_seens_count(banner_tag=get_banner.tag) >= get_banner.banner_limit:
                return await callback_query.answer("🪵 محدودیت این بنر به پایان رسیده است.", True)
                
            elif not await self.database.get_channels_count(user_id=user_id, verify=True):
                return await callback_query.answer("🪵 شما هیچ کانالی برای دریافت بنر ندارید.", True)

            if get_arguments[2] == "NOTHING" or get_arguments[2] not in self.rec_cache:
                random_cache = self.string_generator()
                self.rec_cache[random_cache] = []
            else:
                random_cache = get_arguments[2]

            channels = self.rec_cache[random_cache]

            if get_arguments[3] == "verify":
                if not channels:
                    return await callback_query.answer("🪵 شما هیچ کانالی برای دریافت بنر انتخاب نکرده اید.", True)
                
                for channel in channels:
                    if await self.database.get_channel(banner_tag=get_banner.tag, channel_tag=channel) and not await self.database.get_channel_request(tag=channel):
                        await self.database.add_channel_request(tag=self.string_generator(), banner_tag=get_banner.tag, channel_tag=channel)
                        
                admins = ADMINS.copy()
                async for admin in self.database.get_admins():
                    rights = self.decode(admin.rights)
                    
                    if "banner" in rights:
                        admins.append(admin.user_id)

                for admin in admins:
                    try:
                        await self.client.send_message(
                            chat_id=admin,
                            text="➿ درخواست دریافت بنر جدیدی اضافه شد."
                        )
                    except:
                        pass

                self.rec_cache.pop(random_cache)

                await callback_query.edit_message_text(
                    text="💡 درخواست <b>دریافت بنر</b> شما برای <b>مدیران</b> ارسال شد، پس از <b>تایید بنر</b> در کانال های انتخاب شده <b>ارسال</b> خواهد شد.",
                    reply_markup=None
                )
            
            elif get_arguments[3] == "all":
                async for channel in self.database.get_channels(user_id=user_id, verify=True):
                    if not await self.database.get_channel_request(tag=channel.tag):
                        await self.database.add_channel_request(tag=self.string_generator(), banner_tag=get_banner.tag, channel_tag=channel.tag)
                        
                admins = ADMINS.copy()
                async for admin in self.database.get_admins():
                    rights = self.decode(admin.rights)
                    
                    if "banner" in rights:
                        admins.append(admin.user_id)

                for admin in admins:
                    try:
                        await self.client.send_message(
                            chat_id=admin,
                            text="➿ درخواست دریافت بنر جدیدی اضافه شد."
                        )
                    except:
                        pass

                self.rec_cache.pop(random_cache)

                await callback_query.edit_message_text(
                    text="💡 درخواست <b>دریافت بنر</b> شما برای <b>مدیران</b> ارسال شد، پس از <b>تایید بنر</b> در همه ی کانال های شما <b>ارسال</b> خواهد شد.",
                    reply_markup=None
                )

            else:
                if get_arguments[3] != "normal":
                    get_channel = await self.database.get_channel(tag=get_arguments[3])
                    
                    if not get_channel:
                        return await callback_query.answer("🪵 این کانال دیگر وجود ندارد.", True)

                    elif await self.database.get_channel_request(tag=get_channel.tag):
                        return await callback_query.answer("🪵 شما قبلا درخواست این کانال را داده اید.", True)
                    
                    elif get_channel.channel_type not in self.decode(get_banner.channel_type):
                        return await callback_query.answer(f"🪵 فقط کانال های {' - '.join(list(map(lambda x: self.channel_type(x), self.decode(get_arguments[7]))))} مجاز به دریافت بنر هستند.", True)
                    
                    if get_channel.tag in channels:
                        await callback_query.answer("🪵 انتخاب کانال لغو شد.")
                        channels.remove(get_channel.tag)
                    else:
                        await callback_query.answer("🪵 انتخاب کانال تایید شد.")
                        channels.append(get_channel.tag)
                
                buttons = []
                channel_numbers = await self.database.get_channels_count(user_id=user_id, verify=True)
            
                async for channel in self.database.get_channels(user_id=user_id, verify=True):
                    if channel_numbers > 10:
                        await asyncio.sleep(0.05)

                    try:
                        get_chat = await self.client.get_chat(channel.chat_id)
                        title = get_chat.title
                    except:
                        title = str(channel.chat_id)

                    buttons.append(
                        [
                            InlineKeyboardButton(("✔️ " if channel.tag in channels else "") + title, callback_data=f"rec_banner|{get_banner.tag}|{random_cache}|{channel.tag}")
                        ]
                    )
            
                buttons.append(
                    [
                        InlineKeyboardButton("➿ همه کانال ها", callback_data=f"rec_banner|{get_banner.tag}|{random_cache}|all"),
                        InlineKeyboardButton("✅ تایید", callback_data=f"rec_banner|{get_banner.tag}|{random_cache}|verify")
                    ]
                )
            
                buttons.append(
                    [
                        InlineKeyboardButton("🔙 بازگشت", callback_data=f"banner|{get_banner.tag}|verify")
                    ]
                )

                markup = InlineKeyboardMarkup(buttons)

                try:
                    if get_arguments[3] == "normal":
                        await callback_query.edit_message_text(
                            text=f"""💡 کانال هایی که می خواهید بنر <b>{escape(get_banner.banner_name)}</b> در آن ارسال شود را ارسال کنید.""",
                            reply_markup=markup
                        )
                    else:
                        await callback_query.edit_message_reply_markup(
                            reply_markup=markup
                        )
                except:
                    pass
            
        elif get_arguments[0] == "channel_request":
            get_channel_request = await self.database.get_channel_request(tag=get_arguments[2])
            
            if not get_channel_request:
                return await callback_query.edit_message_text(
                    text="🛡 این درخواست دیگر وجود ندارد."
                )
                
            get_banner = await self.database.get_banner(tag=get_channel_request.banner_tag)

            if not get_banner or get_banner.status:
                await self.database.delete_channel_request(get_channel_request.id)
                return await callback_query.edit_message_text(
                    text="🛡 <b>بنر</b> این <b>درخواست</b> دیگر در <b>دسترس</b> نیست.",
                )

            get_channel = await self.database.get_channel(tag=get_channel_request.channel_tag)

            if not get_channel:
                await self.database.delete_channel_request(get_channel_request.id)
                return await callback_query.edit_message_text(
                    text="🛡 <b>کانال درخوست</b> تایید این <b>بنر</b> دیگر در <b>دسترس</b> نیست.",
                )
    
            elif await self.database.get_seen(banner_tag=get_banner.tag, chat_id=get_channel.chat_id):
                await self.database.delete_channel_request(get_channel_request.id)
                return await callback_query.edit_message_text(
                    text="🛡 این <b>بنر</b> در این کانال <b>وجود</b> دارد."
                )

            try:
                get_chat = await self.client.get_chat(get_channel.chat_id)
                title = get_chat.title
            except:
                title = "-"
                
            if get_arguments[1] == "cancel":
                try:
                    await self.client.send_message(
                        chat_id=get_channel.user_id,
                        text=f"🔴 درخواست بنر {escape(get_banner.banner_name)} برای کانال <b>{escape(title)}</b> توسط ادمین رد شد."
                    )
                except:
                    pass
                
                await callback_query.edit_message_text(
                    text="🛡 درخواست بنر این کاربر رد شد."
                )
                
                await self.database.delete_channel_request(get_channel_request.id)
            else:
                try:
                    sent_message = await self.client.forward_messages(
                        chat_id=get_channel.chat_id,
                        from_chat_id=self.setting.banner_channel,
                        message_ids=get_banner.msg_id
                    )
                except:
                    return await callback_query.answer(f"🛡 ربات در کانال {title} ادمین نیست.", True)

                await self.database.add_seen(tag=self.string_generator(), banner_tag=get_banner.tag, user_id=get_channel.user_id, chat_id=get_channel.chat_id, msg_id=sent_message.id)

                try:
                    await self.client.send_message(
                        chat_id=get_channel.user_id,
                        text=f"🟢 درخواست بنر {escape(get_banner.banner_name)} برای کانال <b>{escape(title)}</b> توسط ادمین تایید شد."
                    )
                except:
                    pass
                
                await callback_query.edit_message_text(
                    text="🛡 درخواست بنر این کاربر تایید شد."
                )
                
                await self.database.delete_channel_request(get_channel_request.id)

        elif get_arguments[0] == "send_again":
            get_seen = await self.database.get_seen(tag=get_arguments[1])
            
            if not get_seen or get_seen.status:
                return await callback_query.edit_message_text(
                    text="🛡 این درخواست دیگر وجود ندارد."
                )
                
            get_banner = await self.database.get_banner(tag=get_seen.banner_tag)

            if not get_banner or get_banner.status:
                return await callback_query.edit_message_text(
                    text="🛡 این <b>بنر</b> دیگر در <b>دسترس</b> نیست.",
                )

            try:
                get_chat = await self.client.get_chat(get_seen.chat_id)
                title = get_chat.title
            except:
                title = "-"

            if get_arguments[2] == "cancel":
                await callback_query.edit_message_text(
                    text="🛡 درخواست <b>ارسال دوباره</b> بنر لغو شد."
                )
            else:
                try:
                    sent_message = await self.client.forward_messages(
                        chat_id=get_seen.chat_id,
                        from_chat_id=self.setting.banner_channel,
                        message_ids=get_banner.msg_id
                    )
                except:
                    return await callback_query.answer(f"🛡 ربات در کانال {title} ادمین نیست.", True)

                await self.database.update_seen(get_seen, msg_id=sent_message.id, count=0)

                await callback_query.edit_message_text(
                    text="🛡 درخواست <b>ارسال دوباره</b> بنر تایید شد."
                )
                
        elif get_arguments[0] == "reshots":
            if get_arguments[1] == "delete":
                get_schedule = await self.database.get_schedule(tag=get_arguments[2])
                
                if get_schedule:
                    await self.database.delete_schedule(get_schedule.tag)
                
            if not await self.database.get_banners_count(status=0):
                return await callback_query.edit_message_text(
                    text="📸 هیچ <b>بنری</b> برای <b>ریشات</b> وجود ندارد."
                )
            
            buttons = []
        
            async for banner in self.database.get_banners(status=0):
                buttons.append(
                    [
                        InlineKeyboardButton(banner.banner_name, callback_data=f"reshot|{banner.tag}|normal")
                    ]
                )
        
            markup = InlineKeyboardMarkup(buttons)
            
            await callback_query.edit_message_text(
                text=f"📸 <b>بنر</b> خود را برای <b>ریشات</b> انتخاب کنید.",
                reply_markup=markup
            )
                
        elif get_arguments[0] == "reshot":
            get_banner = await self.database.get_banner(tag=get_arguments[1], status=0)
            
            if not get_banner:
                return await callback_query.answer("📸 این بنر دیگر وجود ندارد.", True)
            
            elif get_arguments[2] == "normal":
                buttons = []
            
                async for schedule in self.database.get_schedules(banner_tag=get_banner.tag, status=0):
                    buttons.append(
                        [
                            InlineKeyboardButton(self.schedule_text(schedule.date, schedule.stype, True), callback_data=f"schedule|{schedule.tag}|normal")
                        ]
                    )
            
                buttons.append(
                    [
                        InlineKeyboardButton("➕ حلقه ای", callback_data=f"reshot|{get_banner.tag}|add|loop|NONE"),
                        InlineKeyboardButton("➕ معمولی", callback_data=f"reshot|{get_banner.tag}|add|normal|NONE")
                    ]
                )
                buttons.append(
                    [
                        InlineKeyboardButton("➕ زمانی حلقه ای", callback_data=f"reshot|{get_banner.tag}|add|time|loop"),
                        InlineKeyboardButton("➕ زمانی معمولی", callback_data=f"reshot|{get_banner.tag}|add|time|normal")
                    ]
                )
            
                buttons.append(
                    [
                        InlineKeyboardButton("🔙 بازگشت", callback_data="reshots|normal")
                    ]
                )

                markup = InlineKeyboardMarkup(buttons)

                await callback_query.edit_message_text(
                    text=f"📸 <b>زمان ریشات</b> خود را برای بنر <b>{escape(get_banner.banner_name)}</b> انتخاب کنید یا <b>زمان جدیدی</b> اضافه کنید.",
                    reply_markup=markup
                )

            elif get_arguments[2] == "add":
                if get_arguments[3] == "normal":
                    text = f"📸 می خواهید چند <b>دقیقه</b> دیگر این بنر <b>ریشات</b> شود؟"
                elif get_arguments[3] == "loop":
                    text = f"📸 می خواهید هر چند <b>دقیقه یکبار</b> این بنر <b>ریشات</b> شود؟"
                else:
                    text = f"📸 می خواهید چه <b>ساعت و دقیقه</b> این بنر <b>ریشات</b> شود؟"

                await self.database.update_user(get_user, step=f"add_reshot|{get_banner.tag}|{get_arguments[3]}|{get_arguments[4]}")
                await callback_query.message.reply(
                    text=text,
                    reply_markup=Buttons.back
                )

        elif get_arguments[0] == "schedule":
            get_schedule = await self.database.get_schedule(tag=get_arguments[1])
            
            if not get_schedule:
                return await callback_query.answer("📸 این ریشات دیگر وجود ندارد.", True)
            
            get_banner = await self.database.get_banner(tag=get_schedule.banner_tag, status=0)
            
            if not get_banner:
                return await callback_query.answer("📸 این بنر دیگر وجود ندارد.", True)
            
            markup = InlineKeyboardMarkup(
                [
                    [
                        InlineKeyboardButton("❌ حذف", callback_data=f"reshots|delete|{get_schedule.tag}")
                    ],
                    [
                        InlineKeyboardButton("🔙 بازگشت", callback_data=f"reshot|{get_banner.tag}|normal")
                    ]
                ]
            )

            await callback_query.edit_message_text(
                text=f"📸 برای حذف ریشات <b>{self.schedule_text(get_schedule.date, get_schedule.stype)}</b> برای بنر <b>{escape(get_banner.banner_name)}</b> روی دکمه <b>حذف</b> ضربه بزنید.",
                reply_markup=markup
            )
                
        elif get_arguments[0] == "my_banner":
            get_seen = await self.database.get_seen(tag=get_arguments[1])
            
            if not get_seen:
                return await callback_query.answer("🪵 این بنر دیگر وجود ندارد.", True)
            
            get_banner = await self.database.get_banner(tag=get_seen.banner_tag, status=0)
            
            if not get_banner or get_banner.status != 0:
                return await callback_query.answer("🪵 این بنر دیگر وجود ندارد.", True)
                    
            get_seens = await self.database.get_all_seens_count(user_id=user_id, banner_tag=get_banner.tag)
            
            if get_banner.banner_end == 1:
                banner_count = f"➿ ظرفیت: <b>{get_banner.count:,}</b>"
                banner_left = f"<b>{get_banner.count - await self.database.get_all_seens_count(banner_tag=get_banner.tag):,}</b>"
            else:
                banner_count = f"🕐 زمان: <b>{get_banner.count:,} روز</b>"
                banner_left = f"<b>{(get_banner.count - (self.timestamp - get_banner.date) // 86400):,} روز</b>"

            if get_arguments[2] == "disable":
                if not get_banner.disable_access:
                    return await callback_query.answer("⛏️ تغییر وضعیت غیر فعال می باشد.", True)

                elif get_seen.disable:
                    await callback_query.answer("⛏️ بنر شما فعال شد و در کانال شما ارسال خواهد شد.", True)
                    await self.database.update_all_seens(user_id=user_id, banner_tag=get_banner.tag, disable=False)

                else:
                    await callback_query.answer("⛏️ بنر شما غیر فعال شد و دیگر در کانال شما ارسال نمی شود.", True)
                    
                    async def delete_all_msgs():
                        async for seen in self.database.get_seens(user_id=user_id, banner_tag=get_banner.tag):
                            try:
                                await self.client.delete_messages(
                                    chat_id=seen.chat_id,
                                    message_ids=seen.msg_id
                                )
                            except:
                                pass
                        
                    asyncio.create_task(delete_all_msgs())
                    
                    await self.database.update_all_seens(user_id=user_id, banner_tag=get_banner.tag, disable=True)

            if get_banner.disable_access:
                disable_access = [InlineKeyboardButton("⛏️ تغییر وضعیت", callback_data=f"my_banner|{get_seen.tag}|disable")]   
            else:
                disable_access = []

            markup = InlineKeyboardMarkup(
                [
                    [
                        *disable_access
                    ],
                    [
                        InlineKeyboardButton("🔄 بروزرسانی", callback_data=f"my_banner|{get_seen.tag}|refresh")
                    ],
                    [
                        InlineKeyboardButton("🔙 بازگشت", callback_data="my_banners")
                    ]
                ]
            )
            
            try:
                await callback_query.edit_message_text(
                    text=f"""💡 مشخصات بنر به شرح زیر می باشد:

🕯 نام: <b>{escape(get_banner.banner_name)}</b>

➰ سین شما: <b>{get_seens:,}</b>

💵 درآمد شما: <b>{round((get_seens / 1000) * get_banner.s1000):,} تومان</b>
📊 رتبه شما: <b>{await self.database.get_rank(get_banner.tag, user_id)}</b>

{banner_count}
〰️ باقی مانده: {banner_left}

⛏️ وضعیت: <b>{'🟢 فعال' if not get_seen.disable else '🔴 غیرفعال'}</b>

🤖 <b>@{self.client.me.username}</b>""",
                    reply_markup=markup
                )
            except:
                if get_arguments[2] == "refresh":
                    await callback_query.answer("🔄 این بنر درحال حاضر بروز می باشد.", True)
            else:
                if get_arguments[2] == "refresh":
                    await callback_query.answer("🔄 بنر با موفقیت بروزرسانی شد.")
                
        elif get_arguments[0] == "my_banners":
            if not await self.database.get_seens_count(user_id=user_id, status=0):
                return await callback_query.edit_message_text(
                    text="🎗 درحال حاضر شما هیچ بنر فعالی ندارید."
                )
                
            buttons = []
        
            async for seen in self.database.get_group_seens(user_id=user_id, status=0):
                get_banner = await self.database.get_banner(tag=seen.banner_tag)
                banner_name = get_banner.banner_name if get_banner else "بنر"

                buttons.append(
                    [
                        InlineKeyboardButton(banner_name, callback_data=f"my_banner|{seen.tag}|normal")
                    ]
                )
        
            markup = InlineKeyboardMarkup(buttons)
        
            await callback_query.edit_message_text(
                text="🎗 بنر های فعال شما به شرح زیر می باشد، جهت مشاهده ی هرکدام روی آن ضربه بزنید.",
                reply_markup=markup
            )