В админ панель МНОЖЕСТВО кнопок просто - пустышки, можешь это исправить? Именно добавить ЛОГИКУ для данных кнопок! Прям полную реализацию! И отправь ПОЛНЫЙ КОД со всеми изменениями!
```
import os
import sqlite3
import aiosqlite
import asyncio
from dotenv import load_dotenv
from telegram import (
    Update, InlineKeyboardButton, InlineKeyboardMarkup,
    ReplyKeyboardMarkup, KeyboardButton, ChatPermissions,
    Bot, BotCommand
)
from telegram.ext import (
    Application, CommandHandler, MessageHandler,
    CallbackQueryHandler, ContextTypes, filters
)
from telegram.constants import ParseMode
from telegram.error import BadRequest, Forbidden

# 🌈 Загрузка переменных окружения 🌈
load_dotenv()
TOKEN       = os.getenv("BOT_TOKEN")
ADMIN_IDS   = set(map(int, os.getenv("ADMIN_IDS", "").split(",")))     # e.g. "12345,67890"
DB_PATH     = os.getenv("DB_PATH", "bot.db")
WELCOME_GIF = "https://media.giphy.com/media/xT1XGEuQDeXGv92sWs/giphy.gif"
LANGS       = {"ru": "🇷🇺 Русский", "en": "🇺🇸 English"}

# 🎭 Стилизованные эмодзи для разных категорий 🎭
EMOJI = {
    "admin": "👑",
    "server": "🖥️",
    "user": "👤",
    "vps": "🚀",
    "subscription": "📢",
    "success": "✅",
    "error": "❌",
    "warning": "⚠️",
    "info": "ℹ️",
    "new": "🆕",
    "delete": "🗑️",
    "edit": "✏️",
    "list": "📋",
    "settings": "⚙️",
    "language": "🌐",
    "invite": "🔗",
    "stats": "📊",
    "cpu": "🧠",
    "ram": "🧵",
    "disk": "💽",
    "ip": "🌍",
    "login": "👤",
    "password": "🔑",
    "id": "🆔",
    "gift": "🎁",
    "money": "💰",
    "time": "⏰",
    "check": "✓",
    "cross": "✗",
    "star": "⭐",
    "heart": "❤️",
    "fire": "🔥",
    "rocket": "🚀",
    "lock": "🔒",
    "unlock": "🔓",
    "mail": "📧",
    "phone": "📱",
    "web": "🌐",
    "link": "🔗",
    "search": "🔍",
    "calendar": "📅",
    "clock": "🕒",
    "chart": "📈",
    "folder": "📁",
    "file": "📄",
    "camera": "📷",
    "video": "🎥",
    "music": "🎵",
    "game": "🎮",
    "sport": "🏆",
    "food": "🍔",
    "drink": "🍹",
    "travel": "✈️",
    "weather": "🌤️",
    "home": "🏠",
    "work": "💼",
    "school": "🏫",
    "book": "📚",
    "note": "📝",
    "idea": "💡",
    "like": "👍",
    "dislike": "👎",
    "smile": "😊",
    "sad": "😢",
    "laugh": "😂",
    "cool": "😎",
    "love": "😍",
    "think": "🤔",
    "sleep": "😴",
    "angry": "😡",
    "surprise": "😮",
    "confused": "😕",
    "sick": "🤒",
    "devil": "😈",
    "angel": "😇",
    "alien": "👽",
    "ghost": "👻",
    "robot": "🤖",
    "poop": "💩",
    "clown": "🤡",
    "monkey": "🐵",
    "dog": "🐶",
    "cat": "🐱",
    "mouse": "🐭",
    "hamster": "🐹",
    "rabbit": "🐰",
    "fox": "🦊",
    "bear": "🐻",
    "panda": "🐼",
    "koala": "🐨",
    "tiger": "🐯",
    "lion": "🦁",
    "cow": "🐮",
    "pig": "🐷",
    "frog": "🐸",
    "monkey_face": "🐵",
    "see_no_evil": "🙈",
    "hear_no_evil": "🙉",
    "speak_no_evil": "🙊",
}

# 🎨 Стили текста для разных типов сообщений 🎨
TEXT_STYLES = {
    "header": lambda text: f"<b>🔶 {text} 🔶</b>",
    "subheader": lambda text: f"<b>✨ {text} ✨</b>",
    "success": lambda text: f"<b>{EMOJI['success']} {text}</b>",
    "error": lambda text: f"<b>{EMOJI['error']} {text}</b>",
    "warning": lambda text: f"<b>{EMOJI['warning']} {text}</b>",
    "info": lambda text: f"<i>{EMOJI['info']} {text}</i>",
    "code": lambda text: f"<code>{text}</code>",
    "bold": lambda text: f"<b>{text}</b>",
    "italic": lambda text: f"<i>{text}</i>",
    "underline": lambda text: f"<u>{text}</u>",
    "strikethrough": lambda text: f"
{text}
",
    "link": lambda text, url: f'<a href="{url}">{text}</a>',
    "mention": lambda text, user_id: f'<a href="tg://user?id={user_id}">{text}</a>',
}

async def init_db():
    """🗄️ Инициализация базы данных 🗄"""
    async with aiosqlite.connect(DB_PATH) as db:
        # Users, with optional language choice
        await db.execute('''CREATE TABLE IF NOT EXISTS users (
            user_id       INTEGER PRIMARY KEY,
            username      TEXT,
            referrer_id   INTEGER,
            invited_count INTEGER DEFAULT 0,
            lang          TEXT DEFAULT 'ru',
            joined_date   TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )''')
        # VPS servers
        await db.execute('''CREATE TABLE IF NOT EXISTS servers (
            id        INTEGER PRIMARY KEY AUTOINCREMENT,
            ip        TEXT UNIQUE,
            login     TEXT,
            password  TEXT,
            vcpu      INTEGER,
            ram       INTEGER,
            disk      INTEGER,
            owner_id  INTEGER,
            added_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )''')
        # Channels to require subscription
        await db.execute('''CREATE TABLE IF NOT EXISTS channels (
            chat_id   INTEGER PRIMARY KEY,
            title     TEXT,
            required  BOOLEAN DEFAULT 1,
            added_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )''')
        await db.commit()

def admin_only(func):
    """👑 Декоратор для команд только для администраторов 👑"""
    async def wrapper(update: Update, context: ContextTypes.DEFAULT_TYPE):
        user_id = update.effective_user.id
        if user_id not in ADMIN_IDS:
            await update.message.reply_text(
                TEXT_STYLES["error"]("Доступ только для администраторов! У вас нет прав для выполнения этой команды. 🔐"),
                parse_mode=ParseMode.HTML
            )
            return
        return await func(update, context)
    return wrapper

def get_main_keyboard(lang: str):
    """🎮 Основная клавиатура пользователя 🎮"""
    if lang == "en":
        buttons = [
            [f"{EMOJI['user']} My Profile", f"{EMOJI['server']} My Servers"],
            [f"{EMOJI['vps']} Get VPS", f"{EMOJI['subscription']} Check Subscriptions"],
            [f"{EMOJI['language']} Change Language", f"{EMOJI['info']} Help"]
        ]
    else:
        buttons = [
            [f"{EMOJI['user']} Мой Профиль", f"{EMOJI['server']} Мои Сервера"],
            [f"{EMOJI['vps']} Получить VPS", f"{EMOJI['subscription']} Проверить Подписки"],
            [f"{EMOJI['language']} Сменить Язык", f"{EMOJI['info']} Помощь"]
        ]
    return ReplyKeyboardMarkup(buttons, resize_keyboard=True)

def get_admin_keyboard():
    """👑 Клавиатура администратора 👑"""
    buttons = [
        [f"{EMOJI['admin']} Админ-панель"],
        [f"{EMOJI['user']} Мой Профиль", f"{EMOJI['server']} Мои Сервера"],
        [f"{EMOJI['vps']} Получить VPS", f"{EMOJI['subscription']} Проверить Подписки"],
        [f"{EMOJI['language']} Сменить Язык", f"{EMOJI['info']} Помощь"]
    ]
    return ReplyKeyboardMarkup(buttons, resize_keyboard=True)

def get_admin_panel_keyboard():
    """👑 Клавиатура админ-панели 👑"""
    buttons = [
        [
            InlineKeyboardButton(f"{EMOJI['server']} Управление серверами", callback_data="admin_servers"),
            InlineKeyboardButton(f"{EMOJI['subscription']} Управление каналами", callback_data="admin_channels")
        ],
        [
            InlineKeyboardButton(f"{EMOJI['user']} Управление пользователями", callback_data="admin_users"),
            InlineKeyboardButton(f"{EMOJI['stats']} Статистика", callback_data="admin_stats")
        ],
        [
            InlineKeyboardButton(f"{EMOJI['settings']} Настройки", callback_data="admin_settings"),
            InlineKeyboardButton(f"{EMOJI['home']} Главное меню", callback_data="admin_back")
        ]
    ]
    return InlineKeyboardMarkup(buttons)

def get_server_management_keyboard():
    """🖥️ Клавиатура управления серверами 🖥️"""
    buttons = [
        [
            InlineKeyboardButton(f"{EMOJI['new']} Добавить сервер", callback_data="admin_add_server"),
            InlineKeyboardButton(f"{EMOJI['list']} Список серверов", callback_data="admin_list_servers")
        ],
        [
            InlineKeyboardButton(f"{EMOJI['delete']} Удалить сервер", callback_data="admin_del_server"),
            InlineKeyboardButton(f"{EMOJI['edit']} Изменить сервер", callback_data="admin_edit_server")
        ],
        [
            InlineKeyboardButton(f"⬅️ Назад", callback_data="admin_panel")
        ]
    ]
    return InlineKeyboardMarkup(buttons)

def get_channel_management_keyboard():
    """📢 Клавиатура управления каналами 📢"""
    buttons = [
        [
            InlineKeyboardButton(f"{EMOJI['new']} Добавить канал", callback_data="admin_add_channel"),
            InlineKeyboardButton(f"{EMOJI['list']} Список каналов", callback_data="admin_list_channels")
        ],
        [
            InlineKeyboardButton(f"{EMOJI['delete']} Удалить канал", callback_data="admin_del_channel"),
            InlineKeyboardButton(f"{EMOJI['edit']} Изменить канал", callback_data="admin_edit_channel")
        ],
        [
            InlineKeyboardButton(f"⬅️ Назад", callback_data="admin_panel")
        ]
    ]
    return InlineKeyboardMarkup(buttons)

def get_user_management_keyboard():
    """👤 Клавиатура управления пользователями 👤"""
    buttons = [
        [
            InlineKeyboardButton(f"{EMOJI['list']} Список пользователей", callback_data="admin_list_users"),
            InlineKeyboardButton(f"{EMOJI['search']} Найти пользователя", callback_data="admin_find_user")
        ],
        [
            InlineKeyboardButton(f"{EMOJI['edit']} Изменить пользователя", callback_data="admin_edit_user"),
            InlineKeyboardButton(f"{EMOJI['gift']} Выдать VPS", callback_data="admin_give_vps")
        ],
        [
            InlineKeyboardButton(f"⬅️ Назад", callback_data="admin_panel")
        ]
    ]
    return InlineKeyboardMarkup(buttons)

async def get_user_lang(db, user_id: int) -> str:
    """🌐 Получение языка пользователя 🌐"""
    async with db.execute("SELECT lang FROM users WHERE user_id = ?", (user_id,)) as cur:
        row = await cur.fetchone()
    return row[0] if row else "ru"

async def is_subscribed(db, bot, user_id: int) -> tuple:
    """📢 Проверка подписки на каналы 📢"""
    subs = True
    not_subscribed = []
    
    async with db.execute("SELECT chat_id, title FROM channels WHERE required=1") as cur:
        channels = await cur.fetchall()
    
    for cid, title in channels:
        try:
            m = await bot.get_chat_member(cid, user_id)
            if m.status in ("left", "kicked"):
                subs = False
                not_subscribed.append((cid, title))
        except BadRequest:
            # Бот не находится в группе/канале
            subs = False
            not_subscribed.append((cid, title))
        except Exception as e:
            print(f"Error checking subscription: {e}")
            subs = False
            not_subscribed.append((cid, title))
    
    return subs, not_subscribed

async def check_bot_in_channel(bot, chat_id):
    """🤖 Проверка наличия бота в канале/группе 🤖"""
    try:
        bot_id = bot.id
        member = await bot.get_chat_member(chat_id, bot_id)
        return True
    except Exception:
        return False

### Handlers ###

async def cmd_start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """🚀 Обработчик команды /start 🚀"""
    user = update.effective_user
    args = context.args
    referrer = None
    if args:
        try:
            ref = int(args[0])
            if ref != user.id:
                referrer = ref
        except:
            pass

    async with aiosqlite.connect(DB_PATH) as db:
        # new user?
        async with db.execute("SELECT * FROM users WHERE user_id = ?", (user.id,)) as cur:
            exists = await cur.fetchone()
        if not exists:
            await db.execute(
                "INSERT INTO users(user_id, username, referrer_id) VALUES(?,?,?)",
                (user.id, user.username, referrer)
            )
            if referrer:
                await db.execute(
                    "UPDATE users SET invited_count = invited_count + 1 WHERE user_id = ?",
                    (referrer,)
                )
                # Уведомление реферера
                try:
                    await context.bot.send_message(
                        chat_id=referrer,
                        text=TEXT_STYLES["success"](f"🎉 Поздравляем! Пользователь {user.first_name} (@{user.username or 'без имени пользователя'}) зарегистрировался по вашей ссылке! 🎁"),
                        parse_mode=ParseMode.HTML
                    )
                except:
                    pass
        await db.commit()
        lang = await get_user_lang(db, user.id)

    # Отправляем приветственную анимацию
    await context.bot.send_animation(chat_id=update.effective_chat.id, animation=WELCOME_GIF)
    
    # Выбираем клавиатуру в зависимости от роли пользователя
    keyboard = get_admin_keyboard() if user.id in ADMIN_IDS else get_main_keyboard(lang)
    
    # Приветственное сообщение с форматированием
    if lang == "ru":
        welcome_text = f"""
{TEXT_STYLES["header"]("Добро пожаловать в VPS Bot!")}

{TEXT_STYLES["subheader"]("Что вы можете делать:")}
- {EMOJI["user"]} Просматривать свой профиль
- {EMOJI["server"]} Управлять своими серверами
- {EMOJI["vps"]} Получить бесплатный VPS
- {EMOJI["subscription"]} Проверить подписки на каналы
- {EMOJI["invite"]} Приглашать друзей и получать бонусы

{TEXT_STYLES["info"]("Используйте кнопки ниже для навигации")}
        """
    else:
        welcome_text = f"""
{TEXT_STYLES["header"]("Welcome to VPS Bot!")}

{TEXT_STYLES["subheader"]("What you can do:")}
- {EMOJI["user"]} View your profile
- {EMOJI["server"]} Manage your servers
- {EMOJI["vps"]} Get a free VPS
- {EMOJI["subscription"]} Check channel subscriptions
- {EMOJI["invite"]} Invite friends and get bonuses

{TEXT_STYLES["info"]("Use the buttons below to navigate")}
        """
    
    await update.message.reply_text(
        welcome_text,
        reply_markup=keyboard,
        parse_mode=ParseMode.HTML
    )

async def cmd_lang(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """🌐 Обработчик команды /lang 🌐"""
    # Предлагаем выбор языка с красивыми кнопками
    kb = InlineKeyboardMarkup([
        [
            InlineKeyboardButton(f"🇷🇺 Русский язык", callback_data="setlang_ru"),
            InlineKeyboardButton(f"🇺🇸 English language", callback_data="setlang_en")
        ]
    ])
    
    lang_text = TEXT_STYLES["header"]("Выберите язык интерфейса:") if update.effective_user.language_code.startswith("ru") else TEXT_STYLES["header"]("Choose interface language:")
    
    await update.message.reply_text(
        f"{lang_text}\n\n"
        f"{TEXT_STYLES['info']('Это изменит язык всех сообщений бота')}" if update.effective_user.language_code.startswith("ru") 
        else f"{lang_text}\n\n"
        f"{TEXT_STYLES['info']('This will change the language of all bot messages')}",
        reply_markup=kb,
        parse_mode=ParseMode.HTML
    )

async def cb_setlang(update, context):
    """🌐 Обработчик выбора языка 🌐"""
    query = update.callback_query
    await query.answer()
    lang = query.data.split("_")[1]
    user_id = query.from_user.id
    
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("UPDATE users SET lang = ? WHERE user_id = ?", (lang, user_id))
        await db.commit()
    
    # Красивое сообщение о смене языка
    if lang == "ru":
        text = f"""
{TEXT_STYLES["success"]("Язык успешно изменен!")}

{TEXT_STYLES["info"]("Теперь бот будет общаться с вами на русском языке")}

{EMOJI["smile"]} Приятного использования!
        """
    else:
        text = f"""
{TEXT_STYLES["success"]("Language successfully changed!")}

{TEXT_STYLES["info"]("Now the bot will communicate with you in English")}

{EMOJI["smile"]} Enjoy using the bot!
        """
    
    await query.edit_message_text(
        text,
        parse_mode=ParseMode.HTML,
        reply_markup=InlineKeyboardMarkup([[
            InlineKeyboardButton("🏠 Главное меню" if lang == "ru" else "🏠 Main Menu", callback_data="main_menu")
        ]])
    )

async def cb_main_menu(update, context):
    """🏠 Обработчик возврата в главное меню 🏠"""
    query = update.callback_query
    await query.answer()
    user_id = query.from_user.id
    
    async with aiosqlite.connect(DB_PATH) as db:
        lang = await get_user_lang(db, user_id)
    
    keyboard = get_admin_keyboard() if user_id in ADMIN_IDS else get_main_keyboard(lang)
    
    if lang == "ru":
        text = TEXT_STYLES["header"]("Главное меню")
    else:
        text = TEXT_STYLES["header"]("Main Menu")
    
    try:
        await query.edit_message_text(
            text,
            parse_mode=ParseMode.HTML
        )
    except:
        pass
    
    await context.bot.send_message(
        chat_id=user_id,
        text=text,
        parse_mode=ParseMode.HTML,
        reply_markup=keyboard
    )

async def handle_text(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """📝 Обработчик текстовых сообщений 📝"""
    text = update.message.text
    user = update.effective_user
    async with aiosqlite.connect(DB_PATH) as db:
        lang = await get_user_lang(db, user.id)

    # Админ-панель
    if f"{EMOJI['admin']} Админ-панель" in text and user.id in ADMIN_IDS:
        await update.message.reply_text(
            TEXT_STYLES["header"]("👑 Панель администратора 👑") + "\n\n" +
            TEXT_STYLES["subheader"]("Выберите раздел для управления:"),
            reply_markup=get_admin_panel_keyboard(),
            parse_mode=ParseMode.HTML
        )
        return

    # Профиль
    if f"{EMOJI['user']} Мой Профиль" in text or f"{EMOJI['user']} My Profile" in text:
        async with aiosqlite.connect(DB_PATH) as db:
            cur = await db.execute("""
                SELECT u.invited_count, u.referrer_id, u.joined_date, 
                       (SELECT COUNT(*) FROM servers WHERE owner_id = u.user_id) as servers_count
                FROM users u WHERE u.user_id = ?
            """, (user.id,))
            row = await cur.fetchone()
            if not row:
                return await update.message.reply_text(TEXT_STYLES["error"]("Ошибка получения данных профиля"))
            
            invited, referrer_id, joined_date, servers_count = row
            
            # Получаем информацию о реферере
            referrer_name = None
            if referrer_id:
                cur = await db.execute("SELECT username FROM users WHERE user_id = ?", (referrer_id,))
                ref_row = await cur.fetchone()
                if ref_row:
                    referrer_name = ref_row[0] or f"ID: {referrer_id}"
            
            # Получаем список рефералов
            cur = await db.execute("SELECT user_id, username FROM users WHERE referrer_id = ?", (user.id,))
            referrals = await cur.fetchall()
            
            # Форматируем дату регистрации
            joined_date = joined_date.split(" ")[0] if joined_date else "N/A"
        
        # Создаем красивый профиль
        if lang == "ru":
            profile_text = f"""
{TEXT_STYLES["header"]("👤 Ваш Профиль 👤")}

{EMOJI["id"]} <b>ID:</b> {user.id}
{EMOJI["user"]} <b>Имя:</b> {user.first_name} {user.last_name or ""}
{EMOJI["mail"]} <b>Username:</b> @{user.username or "отсутствует"}

{EMOJI["calendar"]} <b>Дата регистрации:</b> {joined_date}
{EMOJI["server"]} <b>Количество серверов:</b> {servers_count}
{EMOJI["invite"]} <b>Приглашено пользователей:</b> {invited}
{EMOJI["gift"]} <b>Доступно VPS:</b> {invited // 3}

{TEXT_STYLES["subheader"]("Реферальная система")}
{EMOJI["link"]} <b>Ваша реферальная ссылка:</b>
{TEXT_STYLES["code"](f"https://t.me/{context.bot.username}?start={user.id}")}

{EMOJI["user"]} <b>Вас пригласил:</b> {f"@{referrer_name}" if referrer_name else "Никто"}

{TEXT_STYLES["subheader"]("Ваши рефералы")}
"""
            if referrals:
                for i, (ref_id, ref_name) in enumerate(referrals, 1):
                    profile_text += f"{i}. {EMOJI['user']} {ref_name or f'ID: {ref_id}'}\n"
            else:
                profile_text += f"{EMOJI['info']} У вас пока нет рефералов\n"
                
            profile_text += f"\n{TEXT_STYLES['info']('Пригласите 3 пользователей и получите бесплатный VPS!')}"
        else:
            profile_text = f"""
{TEXT_STYLES["header"]("👤 Your Profile 👤")}

{EMOJI["id"]} <b>ID:</b> {user.id}
{EMOJI["user"]} <b>Name:</b> {user.first_name} {user.last_name or ""}
{EMOJI["mail"]} <b>Username:</b> @{user.username or "not set"}

{EMOJI["calendar"]} <b>Registration date:</b> {joined_date}
{EMOJI["server"]} <b>Servers count:</b> {servers_count}
{EMOJI["invite"]} <b>Invited users:</b> {invited}
{EMOJI["gift"]} <b>Available VPS:</b> {invited // 3}

{TEXT_STYLES["subheader"]("Referral System")}
{EMOJI["link"]} <b>Your referral link:</b>
{TEXT_STYLES["code"](f"https://t.me/{context.bot.username}?start={user.id}")}

{EMOJI["user"]} <b>Invited by:</b> {f"@{referrer_name}" if referrer_name else "Nobody"}

{TEXT_STYLES["subheader"]("Your Referrals")}
"""
            if referrals:
                for i, (ref_id, ref_name) in enumerate(referrals, 1):
                    profile_text += f"{i}. {EMOJI['user']} {ref_name or f'ID: {ref_id}'}\n"
            else:
                profile_text += f"{EMOJI['info']} You don't have any referrals yet\n"
                
            profile_text += f"\n{TEXT_STYLES['info']('Invite 3 users and get a free VPS!')}"
        
        # Добавляем кнопки для копирования реферальной ссылки
        kb = InlineKeyboardMarkup([[
            InlineKeyboardButton(
                f"{EMOJI['link']} {'Скопировать ссылку' if lang == 'ru' else 'Copy link'}", 
                url=f"https://t.me/{context.bot.username}?start={user.id}"
            )
        ]])
        
        await update.message.reply_text(
            profile_text,
            parse_mode=ParseMode.HTML,
            reply_markup=kb
        )

    # Мои сервера
    elif f"{EMOJI['server']} Мои Сервера" in text or f"{EMOJI['server']} My Servers" in text:
        async with aiosqlite.connect(DB_PATH) as db:
            cur = await db.execute("""
                SELECT id, ip, login, password, vcpu, ram, disk, 
                added_date FROM servers WHERE owner_id = ?
            """, (user.id,))
            rows = await cur.fetchall()
        
        if not rows:
            if lang == "ru":
                await update.message.reply_text(
                    TEXT_STYLES["warning"](f"🛑 У вас пока нет серверов.") + "\n\n" +
                    TEXT_STYLES["info"](f"Пригласите 3 пользователей, чтобы получить бесплатный VPS!"),
                    parse_mode=ParseMode.HTML
                )
            else:
                await update.message.reply_text(
                    TEXT_STYLES["warning"](f"🛑 You don't have any servers yet.") + "\n\n" +
                    TEXT_STYLES["info"](f"Invite 3 users to get a free VPS!"),
                    parse_mode=ParseMode.HTML
                )
        else:
            header = TEXT_STYLES["header"](f"🖥️ Ваши серверы ({len(rows)})") if lang == "ru" else TEXT_STYLES["header"](f"🖥️ Your servers ({len(rows)})")
            await update.message.reply_text(header, parse_mode=ParseMode.HTML)
            
            for sid, ip, login, pwd, vcpu, ram, disk, added_date in rows:
                server_text = f"""
{TEXT_STYLES["subheader"](f"Сервер #{sid}")}

{EMOJI["ip"]} <b>IP:</b> {TEXT_STYLES["code"](ip)}
{EMOJI["login"]} <b>Логин:</b> {TEXT_STYLES["code"](login)}
{EMOJI["password"]} <b>Пароль:</b> {TEXT_STYLES["code"](pwd)}

{TEXT_STYLES["subheader"]("Характеристики")}
{EMOJI["cpu"]} <b>CPU:</b> {vcpu} vCPU
{EMOJI["ram"]} <b>RAM:</b> {ram} MB
{EMOJI["disk"]} <b>Диск:</b> {disk} GB

{EMOJI["calendar"]} <b>Добавлен:</b> {added_date.split(" ")[0] if added_date else "N/A"}
"""
                if lang == "en":
                    server_text = f"""
{TEXT_STYLES["subheader"](f"Server #{sid}")}

{EMOJI["ip"]} <b>IP:</b> {TEXT_STYLES["code"](ip)}
{EMOJI["login"]} <b>Login:</b> {TEXT_STYLES["code"](login)}
{EMOJI["password"]} <b>Password:</b> {TEXT_STYLES["code"](pwd)}

{TEXT_STYLES["subheader"]("Specifications")}
{EMOJI["cpu"]} <b>CPU:</b> {vcpu} vCPU
{EMOJI["ram"]} <b>RAM:</b> {ram} MB
{EMOJI["disk"]} <b>Disk:</b> {disk} GB

{EMOJI["calendar"]} <b>Added:</b> {added_date.split(" ")[0] if added_date else "N/A"}
"""
                
                # Кнопки для управления сервером
                kb = InlineKeyboardMarkup([
                    [
                        InlineKeyboardButton(
                            f"{EMOJI['web']} {'Подключиться' if lang == 'ru' else 'Connect'}", 
                            url=f"ssh://{login}:{pwd}@{ip}"
                        )
                    ]
                ])
                
                await update.message.reply_text(
                    server_text,
                    parse_mode=ParseMode.HTML,
                    reply_markup=kb
                )

    # Получить VPS
    elif f"{EMOJI['vps']} Получить VPS" in text or f"{EMOJI['vps']} Get VPS" in text:
        async with aiosqlite.connect(DB_PATH) as db:
            cur = await db.execute("SELECT invited_count FROM users WHERE user_id = ?", (user.id,))
            cnt = (await cur.fetchone())[0] or 0
            
            if cnt < 3:
                if lang == "ru":
                    await update.message.reply_text(
                        TEXT_STYLES["warning"](f"❗ Для получения VPS нужно пригласить 3 пользователей!") + "\n\n" +
                        TEXT_STYLES["info"](f"У вас приглашено: {cnt}/3") + "\n\n" +
                        TEXT_STYLES["subheader"]("Ваша реферальная ссылка:") + "\n" +
                        TEXT_STYLES["code"](f"https://t.me/{context.bot.username}?start={user.id}"),
                        parse_mode=ParseMode.HTML,
                        reply_markup=InlineKeyboardMarkup([[
                            InlineKeyboardButton(
                                f"{EMOJI['link']} Скопировать ссылку", 
                                url=f"https://t.me/{context.bot.username}?start={user.id}"
                            )
                        ]])
                    )
                else:
                    await update.message.reply_text(
                        TEXT_STYLES["warning"](f"❗ You need to invite 3 users to get a VPS!") + "\n\n" +
                        TEXT_STYLES["info"](f"You have invited: {cnt}/3") + "\n\n" +
                        TEXT_STYLES["subheader"]("Your referral link:") + "\n" +
                        TEXT_STYLES["code"](f"https://t.me/{context.bot.username}?start={user.id}"),
                        parse_mode=ParseMode.HTML,
                        reply_markup=InlineKeyboardMarkup([[
                            InlineKeyboardButton(
                                f"{EMOJI['link']} Copy link", 
                                url=f"https://t.me/{context.bot.username}?start={user.id}"
                            )
                        ]])
                    )
                return
                
            cur = await db.execute("""
                SELECT id, ip, login, password, vcpu, ram, disk 
                FROM servers WHERE owner_id IS NULL LIMIT 1
            """)
            srv = await cur.fetchone()
            
            if not srv:
                if lang == "ru":
                    await update.message.reply_text(
                        TEXT_STYLES["error"]("⛔ К сожалению, свободных серверов не осталось.") + "\n\n" +
                        TEXT_STYLES["info"]("Пожалуйста, попробуйте позже или свяжитесь с администратором."),
                        parse_mode=ParseMode.HTML
                    )
                else:
                    await update.message.reply_text(
                        TEXT_STYLES["error"]("⛔ Unfortunately, there are no available servers left.") + "\n\n" +
                        TEXT_STYLES["info"]("Please try again later or contact the administrator."),
                        parse_mode=ParseMode.HTML
                    )
                return
                
            sid, ip, login, pwd, vcpu, ram, disk = srv
            await db.execute("UPDATE servers SET owner_id = ? WHERE id = ?", (user.id, sid))
            await db.execute("UPDATE users SET invited_count = invited_count - 3 WHERE user_id = ?", (user.id,))
            await db.commit()
            
            if lang == "ru":
                server_text = f"""
{TEXT_STYLES["success"]("🎉 Поздравляем! Вы получили VPS сервер!")}

{TEXT_STYLES["subheader"](f"Сервер #{sid}")}

{EMOJI["ip"]} <b>IP:</b> {TEXT_STYLES["code"](ip)}
{EMOJI["login"]} <b>Логин:</b> {TEXT_STYLES["code"](login)}
{EMOJI["password"]} <b>Пароль:</b> {TEXT_STYLES["code"](pwd)}

{TEXT_STYLES["subheader"]("Характеристики")}
{EMOJI["cpu"]} <b>CPU:</b> {vcpu} vCPU
{EMOJI["ram"]} <b>RAM:</b> {ram} MB
{EMOJI["disk"]} <b>Диск:</b> {disk} GB

{TEXT_STYLES["info"]("Сохраните эти данные! Они также доступны в разделе 'Мои сервера'")}
"""
            else:
                server_text = f"""
{TEXT_STYLES["success"]("🎉 Congratulations! You've received a VPS server!")}

{TEXT_STYLES["subheader"](f"Server #{sid}")}

{EMOJI["ip"]} <b>IP:</b> {TEXT_STYLES["code"](ip)}
{EMOJI["login"]} <b>Login:</b> {TEXT_STYLES["code"](login)}
{EMOJI["password"]} <b>Password:</b> {TEXT_STYLES["code"](pwd)}

{TEXT_STYLES["subheader"]("Specifications")}
{EMOJI["cpu"]} <b>CPU:</b> {vcpu} vCPU
{EMOJI["ram"]} <b>RAM:</b> {ram} MB
{EMOJI["disk"]} <b>Disk:</b> {disk} GB

{TEXT_STYLES["info"]("Save this information! It's also available in the 'My Servers' section")}
"""
            
            # Кнопки для управления сервером
            kb = InlineKeyboardMarkup([
                [
                    InlineKeyboardButton(
                        f"{EMOJI['web']} {'Подключиться' if lang == 'ru' else 'Connect'}", 
                        url=f"ssh://{login}:{pwd}@{ip}"
                    )
                ]
            ])
            
            await update.message.reply_text(
                server_text,
                parse_mode=ParseMode.HTML,
                reply_markup=kb
            )

    # Проверить подписки
    elif f"{EMOJI['subscription']} Проверить Подписки" in text or f"{EMOJI['subscription']} Check Subscriptions" in text:
        async with aiosqlite.connect(DB_PATH) as db:
            ok, not_subscribed = await is_subscribed(db, context.bot, user.id)
            
            if ok:
                if lang == "ru":
                    await update.message.reply_text(
                        TEXT_STYLES["success"]("✅ Отлично! Вы подписаны на все необходимые каналы!") + "\n\n" +
                        TEXT_STYLES["info"]("Спасибо за поддержку нашего проекта! ❤️"),
                        parse_mode=ParseMode.HTML
                    )
                else:
                    await update.message.reply_text(
                        TEXT_STYLES["success"]("✅ Great! You are subscribed to all required channels!") + "\n\n" +
                        TEXT_STYLES["info"]("Thank you for supporting our project! ❤️"),
                        parse_mode=ParseMode.HTML
                    )
            else:
                # Проверяем, есть ли бот в каналах
                bot_not_in_channels = []
                for cid, title in not_subscribed:
                    if not await check_bot_in_channel(context.bot, cid):
                        bot_not_in_channels.append((cid, title))
                
                # Если бот не в каналах, предлагаем админу добавить бота
                if bot_not_in_channels and user.id in ADMIN_IDS:
                    admin_text = TEXT_STYLES["warning"]("⚠️ Внимание, администратор!") + "\n\n" + \
                                TEXT_STYLES["error"]("Бот не находится в следующих каналах/группах:") + "\n"
                    
                    for cid, title in bot_not_in_channels:
                        admin_text += f"- {title} (ID: {cid})\n"
                    
                    admin_text += "\n" + TEXT_STYLES["info"]("Пожалуйста, добавьте бота в эти каналы/группы для корректной проверки подписок.")
                    
                    await update.message.reply_text(
                        admin_text,
                        parse_mode=ParseMode.HTML
                    )
                
                # Создаем кнопки для подписки
                buttons = []
                for cid, title in not_subscribed:
                    try:
                        chat = await context.bot.get_chat(cid)
                        if chat.username:
                            url = f"https://t.me/{chat.username}"
                        elif chat.invite_link:
                            url = chat.invite_link
                        else:
                            url = f"https://t.me/c/{str(cid)[4:]}"
                        
                        buttons.append([InlineKeyboardButton(f"{EMOJI['subscription']} {title}", url=url)])
                    except Exception as e:
                        print(f"Error getting chat info: {e}")
                
                buttons.append([InlineKeyboardButton(
                    f"{EMOJI['check']} {'Проверить подписки' if lang == 'ru' else 'Check subscriptions'}", 
                    callback_data="check_subs"
                )])
                
                kb = InlineKeyboardMarkup(buttons)
                
                if lang == "ru":
                    await update.message.reply_text(
                        TEXT_STYLES["warning"]("❗ Вы не подписаны на все необходимые каналы!") + "\n\n" +
                        TEXT_STYLES["info"]("Пожалуйста, подпишитесь на следующие каналы:") + "\n\n" +
                        TEXT_STYLES["subheader"]("После подписки нажмите кнопку 'Проверить подписки'"),
                        parse_mode=ParseMode.HTML,
                        reply_markup=kb
                    )
                else:
                    await update.message.reply_text(
                        TEXT_STYLES["warning"]("❗ You are not subscribed to all required channels!") + "\n\n" +
                        TEXT_STYLES["info"]("Please subscribe to the following channels:") + "\n\n" +
                        TEXT_STYLES["subheader"]("After subscribing, click the 'Check subscriptions' button"),
                        parse_mode=ParseMode.HTML,
                        reply_markup=kb
                    )

    # Сменить язык
    elif f"{EMOJI['language']} Сменить Язык" in text or f"{EMOJI['language']} Change Language" in text:
        await cmd_lang(update, context)

    # Помощь
    elif f"{EMOJI['info']} Помощь" in text or f"{EMOJI['info']} Help" in text:
        if lang == "ru":
            help_text = f"""
{TEXT_STYLES["header"]("📚 Справка по боту 📚")}

{TEXT_STYLES["subheader"]("Основные команды:")}
- /start - Запустить бота
- /lang - Изменить язык

{TEXT_STYLES["subheader"]("Как получить VPS?")}
1. Пригласите 3 друзей по вашей реферальной ссылке
2. Перейдите в раздел "Получить VPS"
3. Получите данные для доступа к вашему серверу

{TEXT_STYLES["subheader"]("Реферальная система:")}
- За каждого приглашенного пользователя вы получаете +1 к счетчику приглашений
- За каждые 3 приглашения вы можете получить 1 VPS сервер
- Ваша реферальная ссылка доступна в разделе "Мой профиль"

{TEXT_STYLES["info"]("Если у вас остались вопросы, обратитесь к администратору")}
"""
        else:
            help_text = f"""
{TEXT_STYLES["header"]("📚 Bot Help 📚")}

{TEXT_STYLES["subheader"]("Main commands:")}
- /start - Start the bot
- /lang - Change language

{TEXT_STYLES["subheader"]("How to get a VPS?")}
1. Invite 3 friends using your referral link
2. Go to the "Get VPS" section
3. Get access data for your server

{TEXT_STYLES["subheader"]("Referral system:")}
- For each invited user you get +1 to your invitation counter
- For every 3 invitations you can get 1 VPS server
- Your referral link is available in the "My Profile" section

{TEXT_STYLES["info"]("If you have any questions, please contact the administrator")}
"""
        
        await update.message.reply_text(
            help_text,
            parse_mode=ParseMode.HTML
        )

async def cb_check_subs(update, context):
    """🔄 Обработчик проверки подписок 🔄"""
    query = update.callback_query
    await query.answer()
    user_id = query.from_user.id
    
    async with aiosqlite.connect(DB_PATH) as db:
        lang = await get_user_lang(db, user_id)
        ok, not_subscribed = await is_subscribed(db, context.bot, user_id)
    
    if ok:
        if lang == "ru":
            await query.edit_message_text(
                TEXT_STYLES["success"]("✅ Отлично! Вы подписаны на все необходимые каналы!") + "\n\n" +
                TEXT_STYLES["info"]("Спасибо за поддержку нашего проекта! ❤️"),
                parse_mode=ParseMode.HTML
            )
        else:
            await query.edit_message_text(
                TEXT_STYLES["success"]("✅ Great! You are subscribed to all required channels!") + "\n\n" +
                TEXT_STYLES["info"]("Thank you for supporting our project! ❤️"),
                parse_mode=ParseMode.HTML
            )
    else:
        # Создаем кнопки для подписки
        buttons = []
        for cid, title in not_subscribed:
            try:
                chat = await context.bot.get_chat(cid)
                if chat.username:
                    url = f"https://t.me/{chat.username}"
                elif chat.invite_link:
                    url = chat.invite_link
                else:
                    url = f"https://t.me/c/{str(cid)[4:]}"
                
                buttons.append([InlineKeyboardButton(f"{EMOJI['subscription']} {title}", url=url)])
            except Exception as e:
                print(f"Error getting chat info: {e}")
        
        buttons.append([InlineKeyboardButton(
            f"{EMOJI['check']} {'Проверить подписки' if lang == 'ru' else 'Check subscriptions'}", 
            callback_data="check_subs"
        )])
        
        kb = InlineKeyboardMarkup(buttons)
        
        if lang == "ru":
            await query.edit_message_text(
                TEXT_STYLES["warning"]("❗ Вы все еще не подписаны на все необходимые каналы!") + "\n\n" +
                TEXT_STYLES["info"]("Пожалуйста, подпишитесь на следующие каналы:") + "\n\n" +
                TEXT_STYLES["subheader"]("После подписки нажмите кнопку 'Проверить подписки'"),
                parse_mode=ParseMode.HTML,
                reply_markup=kb
            )
        else:
            await query.edit_message_text(
                TEXT_STYLES["warning"]("❗ You are still not subscribed to all required channels!") + "\n\n" +
                TEXT_STYLES["info"]("Please subscribe to the following channels:") + "\n\n" +
                TEXT_STYLES["subheader"]("After subscribing, click the 'Check subscriptions' button"),
                parse_mode=ParseMode.HTML,
                reply_markup=kb
            )

### Admin Panel Callbacks ###

async def cb_admin_panel(update, context):
    """👑 Обработчик админ-панели 👑"""
    query = update.callback_query
    await query.answer()
    user_id = query.from_user.id
    
    if user_id not in ADMIN_IDS:
        return await query.edit_message_text(
            TEXT_STYLES["error"]("❌ Доступ только для администраторов!"),
            parse_mode=ParseMode.HTML
        )
    
    await query.edit_message_text(
        TEXT_STYLES["header"]("👑 Панель администратора 👑") + "\n\n" +
        TEXT_STYLES["subheader"]("Выберите раздел для управления:"),
        reply_markup=get_admin_panel_keyboard(),
        parse_mode=ParseMode.HTML
    )

async def cb_admin_servers(update, context):
    """🖥️ Обработчик управления серверами 🖥️"""
    query = update.callback_query
    await query.answer()
    user_id = query.from_user.id
    
    if user_id not in ADMIN_IDS:
        return await query.edit_message_text(
            TEXT_STYLES["error"]("❌ Доступ только для администраторов!"),
            parse_mode=ParseMode.HTML
        )
    
    await query.edit_message_text(
        TEXT_STYLES["header"]("🖥️ Управление серверами 🖥️") + "\n\n" +
        TEXT_STYLES["subheader"]("Выберите действие:"),
        reply_markup=get_server_management_keyboard(),
        parse_mode=ParseMode.HTML
    )

async def cb_admin_channels(update, context):
    """📢 Обработчик управления каналами 📢"""
    query = update.callback_query
    await query.answer()
    user_id = query.from_user.id
    
    if user_id not in ADMIN_IDS:
        return await query.edit_message_text(
            TEXT_STYLES["error"]("❌ Доступ только для администраторов!"),
            parse_mode=ParseMode.HTML
        )
    
    await query.edit_message_text(
        TEXT_STYLES["header"]("📢 Управление каналами 📢") + "\n\n" +
        TEXT_STYLES["subheader"]("Выберите действие:"),
        reply_markup=get_channel_management_keyboard(),
        parse_mode=ParseMode.HTML
    )

async def cb_admin_users(update, context):
    """👤 Обработчик управления пользователями 👤"""
    query = update.callback_query
    await query.answer()
    user_id = query.from_user.id
    
    if user_id not in ADMIN_IDS:
        return await query.edit_message_text(
            TEXT_STYLES["error"]("❌ Доступ только для администраторов!"),
            parse_mode=ParseMode.HTML
        )
    
    await query.edit_message_text(
        TEXT_STYLES["header"]("👤 Управление пользователями 👤") + "\n\n" +
        TEXT_STYLES["subheader"]("Выберите действие:"),
        reply_markup=get_user_management_keyboard(),
        parse_mode=ParseMode.HTML
    )

async def cb_admin_list_servers(update, context):
    """📋 Обработчик списка серверов 📋"""
    query = update.callback_query
    await query.answer()
    user_id = query.from_user.id
    
    if user_id not in ADMIN_IDS:
        return await query.edit_message_text(
            TEXT_STYLES["error"]("❌ Доступ только для администраторов!"),
            parse_mode=ParseMode.HTML
        )
    
    async with aiosqlite.connect(DB_PATH) as db:
        cur = await db.execute("""
            SELECT s.id, s.ip, s.owner_id, u.username 
            FROM servers s 
            LEFT JOIN users u ON s.owner_id = u.user_id
            ORDER BY s.id
        """)
        rows = await cur.fetchall()
    
    if not rows:
        await query.edit_message_text(
            TEXT_STYLES["warning"]("⚠️ Нет серверов в базе данных.") + "\n\n" +
            TEXT_STYLES["info"]("Добавьте серверы с помощью команды /addserver или кнопки 'Добавить сервер'"),
            parse_mode=ParseMode.HTML,
            reply_markup=InlineKeyboardMarkup([[
                InlineKeyboardButton("⬅️ Назад", callback_data="admin_servers")
            ]])
        )
        return
    
    text = TEXT_STYLES["header"](f"📋 Список серверов ({len(rows)})") + "\n\n"
    
    for sid, ip, owner_id, username in rows:
        status = f"{EMOJI['user']} {username or owner_id}" if owner_id else f"{EMOJI['success']} свободен"
        text += f"- <b>#{sid}</b> | {EMOJI['ip']} <code>{ip}</code> | {status}\n"
    
    # Разбиваем на страницы, если список слишком длинный
    if len(text) > 4000:
        text = text[:4000] + "...\n\n" + TEXT_STYLES["info"]("Список слишком длинный. Используйте команду /listservers для просмотра полного списка.")
    
    await query.edit_message_text(
        text,
        parse_mode=ParseMode.HTML,
        reply_markup=InlineKeyboardMarkup([[
            InlineKeyboardButton("⬅️ Назад", callback_data="admin_servers")
        ]])
    )

async def cb_admin_list_channels(update, context):
    """📋 Обработчик списка каналов 📋"""
    query = update.callback_query
    await query.answer()
    user_id = query.from_user.id
    
    if user_id not in ADMIN_IDS:
        return await query.edit_message_text(
            TEXT_STYLES["error"]("❌ Доступ только для администраторов!"),
            parse_mode=ParseMode.HTML
        )
    
    async with aiosqlite.connect(DB_PATH) as db:
        cur = await db.execute("SELECT chat_id, title, required FROM channels ORDER BY required DESC, title")
        rows = await cur.fetchall()
    
    if not rows:
        await query.edit_message_text(
            TEXT_STYLES["warning"]("⚠️ Нет каналов в базе данных.") + "\n\n" +
            TEXT_STYLES["info"]("Добавьте каналы с помощью команды /addchannel или кнопки 'Добавить канал'"),
            parse_mode=ParseMode.HTML,
            reply_markup=InlineKeyboardMarkup([[
                InlineKeyboardButton("⬅️ Назад", callback_data="admin_channels")
            ]])
        )
        return
    
    text = TEXT_STYLES["header"](f"📋 Список каналов ({len(rows)})") + "\n\n"
    
    for cid, title, required in rows:
        status = f"{EMOJI['check']} обязательный" if required else f"{EMOJI['info']} необязательный"
        text += f"- <b>{title}</b> | ID: <code>{cid}</code> | {status}\n"
        
        # Проверяем, есть ли бот в канале
        is_bot_in_channel = await check_bot_in_channel(context.bot, cid)
        if not is_bot_in_channel:
            text += f"  {EMOJI['warning']} <i>Бот не добавлен в этот канал!</i>\n"
    
    await query.edit_message_text(
        text,
        parse_mode=ParseMode.HTML,
        reply_markup=InlineKeyboardMarkup([[
            InlineKeyboardButton("⬅️ Назад", callback_data="admin_channels")
        ]])
    )

async def cb_admin_list_users(update, context):
    """📋 Обработчик списка пользователей 📋"""
    query = update.callback_query
    await query.answer()
    user_id = query.from_user.id
    
    if user_id not in ADMIN_IDS:
        return await query.edit_message_text(
            TEXT_STYLES["error"]("❌ Доступ только для администраторов!"),
            parse_mode=ParseMode.HTML
        )
    
    async with aiosqlite.connect(DB_PATH) as db:
        cur = await db.execute("""
            SELECT u.user_id, u.username, u.invited_count, u.joined_date,
                   (SELECT COUNT(*) FROM servers WHERE owner_id = u.user_id) as servers_count
            FROM users u
            ORDER BY u.joined_date DESC
            LIMIT 20
        """)
        rows = await cur.fetchall()
        
        # Общая статистика
        cur = await db.execute("SELECT COUNT(*) FROM users")
        total_users = (await cur.fetchone())[0]
        
        cur = await db.execute("SELECT COUNT(*) FROM servers")
        total_servers = (await cur.fetchone())[0]
        
        cur = await db.execute("SELECT COUNT(*) FROM servers WHERE owner_id IS NOT NULL")
        allocated_servers = (await cur.fetchone())[0]
    
    if not rows:
        await query.edit_message_text(
            TEXT_STYLES["warning"]("⚠️ Нет пользователей в базе данных."),
            parse_mode=ParseMode.HTML,
            reply_markup=InlineKeyboardMarkup([[
                InlineKeyboardButton("⬅️ Назад", callback_data="admin_users")
            ]])
        )
        return
    
    text = TEXT_STYLES["header"](f"📋 Список пользователей ({total_users})") + "\n\n"
    
    text += TEXT_STYLES["subheader"]("Общая статистика:") + "\n"
    text += f"- {EMOJI['user']} Всего пользователей: {total_users}\n"
    text += f"- {EMOJI['server']} Всего серверов: {total_servers}\n"
    text += f"- {EMOJI['vps']} Выдано серверов: {allocated_servers}\n"
    text += f"- {EMOJI['gift']} Доступно серверов: {total_servers - allocated_servers}\n\n"
    
    text += TEXT_STYLES["subheader"]("Последние пользователи:") + "\n"
    
    for uid, username, invited_count, joined_date, servers_count in rows:
        joined_date = joined_date.split(" ")[0] if joined_date else "N/A"
        text += f"- {EMOJI['user']} <b>ID:</b> {uid} | @{username or 'без имени'} | {EMOJI['invite']} {invited_count} | {EMOJI['server']} {servers_count} | {EMOJI['calendar']} {joined_date}\n"
    
    text += f"\n{TEXT_STYLES['info']('Показаны последние 20 пользователей. Используйте команду /listusers для просмотра полного списка.')}"
    
    await query.edit_message_text(
        text,
        parse_mode=ParseMode.HTML,
        reply_markup=InlineKeyboardMarkup([[
            InlineKeyboardButton("⬅️ Назад", callback_data="admin_users")
        ]])
    )

async def cb_admin_stats(update, context):
    """📊 Обработчик статистики 📊"""
    query = update.callback_query
    await query.answer()
    user_id = query.from_user.id
    
    if user_id not in ADMIN_IDS:
        return await query.edit_message_text(
            TEXT_STYLES["error"]("❌ Доступ только для администраторов!"),
            parse_mode=ParseMode.HTML
        )
    
    async with aiosqlite.connect(DB_PATH) as db:
        # Общая статистика
        cur = await db.execute("SELECT COUNT(*) FROM users")
        total_users = (await cur.fetchone())[0]
        
        cur = await db.execute("SELECT COUNT(*) FROM servers")
        total_servers = (await cur.fetchone())[0]
        
        cur = await db.execute("SELECT COUNT(*) FROM servers WHERE owner_id IS NOT NULL")
        allocated_servers = (await cur.fetchone())[0]
        
        cur = await db.execute("SELECT COUNT(*) FROM channels")
        total_channels = (await cur.fetchone())[0]
        
        # Статистика по новым пользователям
        cur = await db.execute("SELECT COUNT(*) FROM users WHERE joined_date >= date('now', '-1 day')")
        new_users_today = (await cur.fetchone())[0]
        
        cur = await db.execute("SELECT COUNT(*) FROM users WHERE joined_date >= date('now', '-7 day')")
        new_users_week = (await cur.fetchone())[0]
        
        # Топ рефереров
        cur = await db.execute("""
            SELECT u.user_id, u.username, u.invited_count
            FROM users u
            WHERE u.invited_count > 0
            ORDER BY u.invited_count DESC
            LIMIT 5
        """)
        top_referrers = await cur.fetchall()
    
    text = TEXT_STYLES["header"]("📊 Статистика бота 📊") + "\n\n"
    
    text += TEXT_STYLES["subheader"]("Общая информация:") + "\n"
    text += f"- {EMOJI['user']} Всего пользователей: {total_users}\n"
    text += f"- {EMOJI['server']} Всего серверов: {total_servers}\n"
    text += f"- {EMOJI['vps']} Выдано серверов: {allocated_servers}\n"
    text += f"- {EMOJI['gift']} Доступно серверов: {total_servers - allocated_servers}\n"
    text += f"- {EMOJI['subscription']} Каналов для подписки: {total_channels}\n\n"
    
    text += TEXT_STYLES["subheader"]("Новые пользователи:") + "\n"
    text += f"- {EMOJI['calendar']} За сегодня: {new_users_today}\n"
    text += f"- {EMOJI['calendar']} За неделю: {new_users_week}\n\n"
    
    text += TEXT_STYLES["subheader"]("Топ рефереров:") + "\n"
    if top_referrers:
        for i, (uid, username, invited_count) in enumerate(top_referrers, 1):
            text += f"{i}. {EMOJI['user']} {username or uid} — {EMOJI['invite']} {invited_count}\n"
    else:
        text += f"{EMOJI['info']} Пока нет активных рефереров\n"
    
    await query.edit_message_text(
        text,
        parse_mode=ParseMode.HTML,
        reply_markup=InlineKeyboardMarkup([[
            InlineKeyboardButton("⬅️ Назад", callback_data="admin_panel")
        ]])
    )

### Admin commands ###

@admin_only
async def cmd_addserver(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """🖥️ Добавление сервера 🖥️"""
    args = context.args
    if len(args) != 6:
        return await update.message.reply_text(
            TEXT_STYLES["error"]("❌ Неверный формат команды!") + "\n\n" +
            TEXT_STYLES["info"]("Использование: /addserver IP login password vCPU RAM(МБ) Disk(ГБ)") + "\n\n" +
            TEXT_STYLES["code"]("/addserver 192.168.1.1 root password123 2 1024 20"),
            parse_mode=ParseMode.HTML
        )
    
    ip, login, pwd, vcpu, ram, disk = args
    async with aiosqlite.connect(DB_PATH) as db:
        try:
            await db.execute(
                "INSERT INTO servers(ip,login,password,vcpu,ram,disk) VALUES(?,?,?,?,?,?)",
                (ip, login, pwd, int(vcpu), int(ram), int(disk))
            )
            await db.commit()
            
            await update.message.reply_text(
                TEXT_STYLES["success"](f"✅ Сервер {ip} успешно добавлен!") + "\n\n" +
                TEXT_STYLES["info"](f"Характеристики: {vcpu} vCPU, {ram} MB RAM, {disk} GB Disk"),
                parse_mode=ParseMode.HTML
            )
        except aiosqlite.IntegrityError:
            await update.message.reply_text(
                TEXT_STYLES["error"]("❗ Сервер с таким IP уже существует в базе данных."),
                parse_mode=ParseMode.HTML
            )
        except ValueError:
            await update.message.reply_text(
                TEXT_STYLES["error"]("❗ Ошибка в числовых параметрах. vCPU, RAM и Disk должны быть числами."),
                parse_mode=ParseMode.HTML
            )

@admin_only
async def cmd_delserver(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """🗑️ Удаление сервера 🗑️"""
    args = context.args
    if len(args) != 1:
        return await update.message.reply_text(
            TEXT_STYLES["error"]("❌ Неверный формат команды!") + "\n\n" +
            TEXT_STYLES["info"]("Использование: /delserver SERVER_ID") + "\n\n" +
            TEXT_STYLES["code"]("/delserver 123"),
            parse_mode=ParseMode.HTML
        )
    
    sid = args[0]
    async with aiosqlite.connect(DB_PATH) as db:
        # Получаем информацию о сервере перед удалением
        cur = await db.execute("SELECT ip, owner_id FROM servers WHERE id = ?", (sid,))
        server = await cur.fetchone()
        
        if not server:
            return await update.message.reply_text(
                TEXT_STYLES["error"]("❗ Сервер с указанным ID не найден."),
                parse_mode=ParseMode.HTML
            )
        
        ip, owner_id = server
        
        # Удаляем сервер
        await db.execute("DELETE FROM servers WHERE id = ?", (sid,))
        await db.commit()
        
        # Уведомляем владельца, если он есть
        if owner_id:
            try:
                async with db.execute("SELECT lang FROM users WHERE user_id = ?", (owner_id,)) as cur:
                    row = await cur.fetchone()
                    lang = row[0] if row else "ru"
                
                if lang == "ru":
                    await context.bot.send_message(
                        chat_id=owner_id,
                        text=TEXT_STYLES["warning"](f"⚠️ Внимание! Ваш сервер #{sid} ({ip}) был удален администратором."),
                        parse_mode=ParseMode.HTML
                    )
                else:
                    await context.bot.send_message(
                        chat_id=owner_id,
                        text=TEXT_STYLES["warning"](f"⚠️ Attention! Your server #{sid} ({ip}) has been deleted by the administrator."),
                        parse_mode=ParseMode.HTML
                    )
            except:
                pass
        
        await update.message.reply_text(
            TEXT_STYLES["success"](f"✅ Сервер #{sid} ({ip}) успешно удален!") + 
            (f"\n\n{TEXT_STYLES['info']('Владелец сервера был уведомлен.')}" if owner_id else ""),
            parse_mode=ParseMode.HTML
        )

@admin_only
async def cmd_listservers(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """📋 Список серверов 📋"""
    async with aiosqlite.connect(DB_PATH) as db:
        cur = await db.execute("""
            SELECT s.id, s.ip, s.owner_id, u.username, s.vcpu, s.ram, s.disk
            FROM servers s 
            LEFT JOIN users u ON s.owner_id = u.user_id
            ORDER BY s.id
        """)
        rows = await cur.fetchall()
    
    if not rows:
        return await update.message.reply_text(
            TEXT_STYLES["warning"]("⚠️ В базе данных нет серверов."),
            parse_mode=ParseMode.HTML
        )
    
    text = TEXT_STYLES["header"](f"📋 Список серверов ({len(rows)})") + "\n\n"
    
    for sid, ip, owner_id, username, vcpu, ram, disk in rows:
        if owner_id:
            status = f"{EMOJI['user']} Выдан: {username or owner_id}"
        else:
            status = f"{EMOJI['success']} Свободен"
        
        text += f"- <b>#{sid}</b> | {EMOJI['ip']} <code>{ip}</code> | {status}\n"
        text += f"  {EMOJI['cpu']} {vcpu} vCPU | {EMOJI['ram']} {ram} MB | {EMOJI['disk']} {disk} GB\n"
    
    # Разбиваем на части, если сообщение слишком длинное
    if len(text) <= 4096:
        await update.message.reply_text(text, parse_mode=ParseMode.HTML)
    else:
        parts = []
        current_part = ""
        for line in text.split("\n"):
            if len(current_part + line + "\n") > 4000:
                parts.append(current_part)
                current_part = line + "\n"
            else:
                current_part += line + "\n"
        
        if current_part:
            parts.append(current_part)
        
        for i, part in enumerate(parts, 1):
            header = f"{TEXT_STYLES['header'](f'📋 Список серверов ({len(rows)}) - Часть {i}/{len(parts)}')} \n\n" if i > 1 else ""
            await update.message.reply_text(header + part, parse_mode=ParseMode.HTML)

@admin_only
async def cmd_addchannel(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """📢 Добавление канала 📢"""
    args = context.args
    if len(args) < 2:
        return await update.message.reply_text(
            TEXT_STYLES["error"]("❌ Неверный формат команды!") + "\n\n" +
            TEXT_STYLES["info"]("Использование: /addchannel CHAT_ID Название") + "\n\n" +
            TEXT_STYLES["code"]("/addchannel -1001234567890 Мой канал"),
            parse_mode=ParseMode.HTML
        )
    
    chat_id = args[0]
    title = " ".join(args[1:])
    
    try:
        chat_id = int(chat_id)
    except ValueError:
        return await update.message.reply_text(
            TEXT_STYLES["error"]("❗ ID канала должен быть числом."),
            parse_mode=ParseMode.HTML
        )
    
    # Проверяем, есть ли бот в канале
    bot_in_channel = await check_bot_in_channel(context.bot, chat_id)
    
    async with aiosqlite.connect(DB_PATH) as db:
        try:
            await db.execute(
                "INSERT INTO channels(chat_id,title) VALUES(?,?)",
                (chat_id, title)
            )
            await db.commit()
            
            success_text = TEXT_STYLES["success"](f"✅ Канал '{title}' успешно добавлен!")
            
            if not bot_in_channel:
                success_text += "\n\n" + TEXT_STYLES["warning"](
                    "⚠️ Внимание! Бот не находится в этом канале/группе. " +
                    "Для корректной проверки подписок необходимо добавить бота в канал."
                )
            
            await update.message.reply_text(success_text, parse_mode=ParseMode.HTML)
        except aiosqlite.IntegrityError:
            await update.message.reply_text(
                TEXT_STYLES["error"]("❗ Канал с таким ID уже существует в базе данных."),
                parse_mode=ParseMode.HTML
            )

@admin_only
async def cmd_delchannel(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """🗑️ Удаление канала 🗑️"""
    args = context.args
    if len(args) != 1:
        return await update.message.reply_text(
            TEXT_STYLES["error"]("❌ Неверный формат команды!") + "\n\n" +
            TEXT_STYLES["info"]("Использование: /delchannel CHAT_ID") + "\n\n" +
            TEXT_STYLES["code"]("/delchannel -1001234567890"),
            parse_mode=ParseMode.HTML
        )
    
    try:
        chat_id = int(args[0])
    except ValueError:
        return await update.message.reply_text(
            TEXT_STYLES["error"]("❗ ID канала должен быть числом."),
            parse_mode=ParseMode.HTML
        )
    
    async with aiosqlite.connect(DB_PATH) as db:
        # Получаем информацию о канале перед удалением
        cur = await db.execute("SELECT title FROM channels WHERE chat_id = ?", (chat_id,))
        channel = await cur.fetchone()
        
        if not channel:
            return await update.message.reply_text(
                TEXT_STYLES["error"]("❗ Канал с указанным ID не найден."),
                parse_mode=ParseMode.HTML
            )
        
        title = channel[0]
        
        # Удаляем канал
        await db.execute("DELETE FROM channels WHERE chat_id = ?", (chat_id,))
        await db.commit()
        
        await update.message.reply_text(
            TEXT_STYLES["success"](f"✅ Канал '{title}' (ID: {chat_id}) успешно удален!"),
            parse_mode=ParseMode.HTML
        )

@admin_only
async def cmd_listchannels(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """📋 Список каналов 📋"""
    async with aiosqlite.connect(DB_PATH) as db:
        cur = await db.execute("SELECT chat_id, title, required FROM channels ORDER BY required DESC, title")
        rows = await cur.fetchall()
    
    if not rows:
        return await update.message.reply_text(
            TEXT_STYLES["warning"]("⚠️ В базе данных нет каналов."),
            parse_mode=ParseMode.HTML
        )
    
    text = TEXT_STYLES["header"](f"📋 Список каналов ({len(rows)})") + "\n\n"
    
    for cid, title, required in rows:
        status = f"{EMOJI['check']} обязательный" if required else f"{EMOJI['info']} необязательный"
        text += f"- <b>{title}</b>\n  ID: <code>{cid}</code> | {status}\n"
        
        # Проверяем, есть ли бот в канале
        is_bot_in_channel = await check_bot_in_channel(context.bot, cid)
        if not is_bot_in_channel:
            text += f"  {EMOJI['warning']} <i>Бот не добавлен в этот канал!</i>\n"
    
    await update.message.reply_text(text, parse_mode=ParseMode.HTML)

@admin_only
async def cmd_listusers(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """📋 Список пользователей 📋"""
    args = context.args
    limit = 20  # По умолчанию показываем 20 пользователей
    
    if args and args[0].isdigit():
        limit = int(args[0])
    
    async with aiosqlite.connect(DB_PATH) as db:
        cur = await db.execute(f"""
            SELECT u.user_id, u.username, u.invited_count, u.joined_date, u.lang,
                   (SELECT COUNT(*) FROM servers WHERE owner_id = u.user_id) as servers_count
            FROM users u
            ORDER BY u.joined_date DESC
            LIMIT {limit}
        """)
        rows = await cur.fetchall()
        
        # Общая статистика
        cur = await db.execute("SELECT COUNT(*) FROM users")
        total_users = (await cur.fetchone())[0]
    
    if not rows:
        return await update.message.reply_text(
            TEXT_STYLES["warning"]("⚠️ В базе данных нет пользователей."),
            parse_mode=ParseMode.HTML
        )
    
    text = TEXT_STYLES["header"](f"📋 Список пользователей ({total_users})") + "\n\n"
    
    for uid, username, invited_count, joined_date, lang, servers_count in rows:
        joined_date = joined_date.split(" ")[0] if joined_date else "N/A"
        text += f"- {EMOJI['user']} <b>ID:</b> {uid}\n"
        text += f"  @{username or 'без имени'} | {EMOJI['language']} {lang} | {EMOJI['invite']} {invited_count} | {EMOJI['server']} {servers_count} | {EMOJI['calendar']} {joined_date}\n"
    
    text += f"\n{TEXT_STYLES['info'](f'Показаны последние {limit} пользователей из {total_users}.')}"
    
    # Разбиваем на части, если сообщение слишком длинное
    if len(text) <= 4096:
        await update.message.reply_text(text, parse_mode=ParseMode.HTML)
    else:
        parts = []
        current_part = ""
        for line in text.split("\n"):
            if len(current_part + line + "\n") > 4000:
                parts.append(current_part)
                current_part = line + "\n"
            else:
                current_part += line + "\n"
        
        if current_part:
            parts.append(current_part)
        
        for i, part in enumerate(parts, 1):
            header = f"{TEXT_STYLES['header'](f'📋 Список пользователей ({total_users}) - Часть {i}/{len(parts)}')} \n\n" if i > 1 else ""
            await update.message.reply_text(header + part, parse_mode=ParseMode.HTML)

@admin_only
async def cmd_viewuser(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """👤 Просмотр информации о пользователе 👤"""
    args = context.args
    if len(args) != 1:
        return await update.message.reply_text(
            TEXT_STYLES["error"]("❌ Неверный формат команды!") + "\n\n" +
            TEXT_STYLES["info"]("Использование: /viewuser USER_ID") + "\n\n" +
            TEXT_STYLES["code"]("/viewuser 123456789"),
            parse_mode=ParseMode.HTML
        )
    
    try:
        uid = int(args[0])
    except ValueError:
        return await update.message.reply_text(
            TEXT_STYLES["error"]("❗ ID пользователя должен быть числом."),
            parse_mode=ParseMode.HTML
        )
    
    async with aiosqlite.connect(DB_PATH) as db:
        cur = await db.execute("""
            SELECT username, referrer_id, invited_count, lang, joined_date
            FROM users WHERE user_id = ?
        """, (uid,))
        user = await cur.fetchone()
        
        if not user:
            return await update.message.reply_text(
                TEXT_STYLES["error"]("❗ Пользователь с указанным ID не найден."),
                parse_mode=ParseMode.HTML
            )
        
        uname, ref, cnt, lang, joined_date = user
        
        # Информация о реферере
        referrer_name = None
        if ref:
            cur = await db.execute("SELECT username FROM users WHERE user_id = ?", (ref,))
            ref_row = await cur.fetchone()
            if ref_row:
                referrer_name = ref_row[0] or f"ID: {ref}"
        
        # Рефералы
        cur = await db.execute("SELECT user_id, username FROM users WHERE referrer_id = ?", (uid,))
        refs = await cur.fetchall()
        
        # Серверы
        cur = await db.execute("SELECT id, ip, vcpu, ram, disk FROM servers WHERE owner_id = ?", (uid,))
        svs = await cur.fetchall()
    
    text = TEXT_STYLES["header"](f"👤 Информация о пользователе") + "\n\n"
    
    text += f"{EMOJI['id']} <b>ID:</b> {uid}\n"
    text += f"{EMOJI['user']} <b>Username:</b> @{uname or 'отсутствует'}\n"
    text += f"{EMOJI['language']} <b>Язык:</b> {lang}\n"
    text += f"{EMOJI['calendar']} <b>Дата регистрации:</b> {joined_date.split(' ')[0] if joined_date else 'N/A'}\n"
    text += f"{EMOJI['invite']} <b>Приглашено:</b> {cnt}\n"
    text += f"{EMOJI['gift']} <b>Доступно VPS:</b> {cnt // 3}\n"
    
    text += f"\n{TEXT_STYLES['subheader']('Реферальная система')}\n"
    text += f"{EMOJI['user']} <b>Приглашен пользователем:</b> {f'@{referrer_name}' if referrer_name else 'Никем'}\n"
    
    text += f"\n{TEXT_STYLES['subheader']('Рефералы')}\n"
    if refs:
        for i, (ref_id, ref_name) in enumerate(refs, 1):
            text += f"{i}. {EMOJI['user']} {ref_name or f'ID: {ref_id}'}\n"
    else:
        text += f"{EMOJI['info']} У пользователя нет рефералов\n"
    
    text += f"\n{TEXT_STYLES['subheader']('Серверы')}\n"
    if svs:
        for i, (sid, ip, vcpu, ram, disk) in enumerate(svs, 1):
            text += f"{i}. #{sid} | {EMOJI['ip']} {ip} | {EMOJI['cpu']} {vcpu} vCPU | {EMOJI['ram']} {ram} MB | {EMOJI['disk']} {disk} GB\n"
    else:
        text += f"{EMOJI['info']} У пользователя нет серверов\n"
    
    # Кнопки для действий с пользователем
    kb = InlineKeyboardMarkup([
        [
            InlineKeyboardButton(f"{EMOJI['gift']} Выдать VPS", callback_data=f"admin_give_vps_{uid}"),
            InlineKeyboardButton(f"{EMOJI['edit']} Изменить", callback_data=f"admin_edit_user_{uid}")
        ]
    ])
    
    await update.message.reply_text(text, parse_mode=ParseMode.HTML, reply_markup=kb)

### Main ###

async def setup_commands(bot: Bot):
    """🔧 Настройка команд бота 🔧"""
    commands = [
        BotCommand("start", "Запустить бота"),
        BotCommand("lang", "Изменить язык"),
        BotCommand("help", "Помощь по боту")
    ]
    
    admin_commands = [
        BotCommand("addserver", "Добавить сервер"),
        BotCommand("delserver", "Удалить сервер"),
        BotCommand("listservers", "Список серверов"),
        BotCommand("addchannel", "Добавить канал"),
        BotCommand("delchannel", "Удалить канал"),
        BotCommand("listchannels", "Список каналов"),
        BotCommand("listusers", "Список пользователей"),
        BotCommand("viewuser", "Информация о пользователе"),
        BotCommand("stats", "Статистика бота")
    ]
    
    await bot.set_my_commands(commands)
    
    # Устанавливаем команды администратора для каждого админа
    for admin_id in ADMIN_IDS:
        try:
            await bot.set_my_commands(commands + admin_commands, scope=BotCommandScopeChat(chat_id=admin_id))
        except Exception as e:
            print(f"Error setting admin commands for {admin_id}: {e}")

def main():
    # Create the application
    application = Application.builder().token(TOKEN).build()
    
    # Initialize the database synchronously
    # This avoids event loop conflicts with the application
    connection = sqlite3.connect(DB_PATH)
    cursor = connection.cursor()
    
    # Create tables
    cursor.execute('''CREATE TABLE IF NOT EXISTS users (
        user_id       INTEGER PRIMARY KEY,
        username      TEXT,
        referrer_id   INTEGER,
        invited_count INTEGER DEFAULT 0,
        lang          TEXT DEFAULT 'ru',
        joined_date   TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    )''')
    
    cursor.execute('''CREATE TABLE IF NOT EXISTS servers (
        id        INTEGER PRIMARY KEY AUTOINCREMENT,
        ip        TEXT UNIQUE,
        login     TEXT,
        password  TEXT,
        vcpu      INTEGER,
        ram       INTEGER,
        disk      INTEGER,
        owner_id  INTEGER,
        added_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    )''')
    
    cursor.execute('''CREATE TABLE IF NOT EXISTS channels (
        chat_id   INTEGER PRIMARY KEY,
        title     TEXT,
        required  BOOLEAN DEFAULT 1,
        added_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    )''')
    
    connection.commit()
    connection.close()
    
    # Register handlers
    # Публичные команды
    application.add_handler(CommandHandler("start", cmd_start))
    application.add_handler(CommandHandler("lang", cmd_lang))
    application.add_handler(CallbackQueryHandler(cb_setlang, pattern="^setlang_"))
    application.add_handler(CallbackQueryHandler(cb_main_menu, pattern="^main_menu$"))
    application.add_handler(CallbackQueryHandler(cb_check_subs, pattern="^check_subs$"))
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_text))
    
    # Админ-панель
    application.add_handler(CallbackQueryHandler(cb_admin_panel, pattern="^admin_panel$"))
    application.add_handler(CallbackQueryHandler(cb_admin_servers, pattern="^admin_servers$"))
    application.add_handler(CallbackQueryHandler(cb_admin_channels, pattern="^admin_channels$"))
    application.add_handler(CallbackQueryHandler(cb_admin_users, pattern="^admin_users$"))
    application.add_handler(CallbackQueryHandler(cb_admin_list_servers, pattern="^admin_list_servers$"))
    application.add_handler(CallbackQueryHandler(cb_admin_list_channels, pattern="^admin_list_channels$"))
    application.add_handler(CallbackQueryHandler(cb_admin_list_users, pattern="^admin_list_users$"))
    application.add_handler(CallbackQueryHandler(cb_admin_stats, pattern="^admin_stats$"))
    
    # Админ-команды
    application.add_handler(CommandHandler("addserver", cmd_addserver))
    application.add_handler(CommandHandler("delserver", cmd_delserver))
    application.add_handler(CommandHandler("listservers", cmd_listservers))
    application.add_handler(CommandHandler("addchannel", cmd_addchannel))
    application.add_handler(CommandHandler("delchannel", cmd_delchannel))
    application.add_handler(CommandHandler("listchannels", cmd_listchannels))
    application.add_handler(CommandHandler("listusers", cmd_listusers))
    application.add_handler(CommandHandler("viewuser", cmd_viewuser))
    
    print(f"{EMOJI['rocket']} Бот запущен и готов к работе!")
    
    # Запуск бота
    application.run_polling()

if __name__ == "__main__":
    main()
```