Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-mini-2025-04-14· OpenAIAi2 WildChat-4.8M (AI2)

import datetime import logging import asyncio import aiosqlite from aiogram import Bot,…

  1. User

    import datetime import logging import asyncio import aiosqlite from aiogram import Bot, Dispatcher, types from aiogram.contrib.fsm_storage.memory import MemoryStorage from aiogram.dispatcher import FSMContext from aiogram.dispatcher.filters.state import State, StatesGroup from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton from aiogram.utils import executor from config import TOKEN, CHANNEL_ID, REQUIRED_CHANNELS, ADMINS

    Настройка логирования

    logging.basicConfig(level=logging.INFO) logger = logging.getLogger(name)

    Инициализация бота и диспетчера

    bot = Bot(token=TOKEN) storage = MemoryStorage() dp = Dispatcher(bot, storage=storage)

    Глобальная переменная для базы данных

    db = None db_path = 'lobbies.db'

    Словарь разрешенных пользователей {telegram_id: "pro_gamer_nickname"}

    ALLOWED_USERS = {

    1164013363: "Creativ",

    # другие пользователи...

    }

    Тексты для режимов игры

    mode_text = { 'mode_free_for_all': 'Против всех (DM)', 'mode_escalation': 'Эскалация' }

    Тексты для карт

    map_text = { 'map_sandstone': 'Sandstone', 'map_rust': 'Rust', 'map_province': 'Province', 'map_breeze': 'Breeze', 'map_dune': 'Dune', 'map_sakura': 'Sakura', 'map_zone7': 'Zone 7' }

    Тексты для времени

    time_text = { 'time_5': '5 минут', 'time_10': '10 минут', 'time_20': '20 минут', 'time_60': '60 минут' }

    Тексты для хитбоксов

    hitbox_text = { 'hitbox_onlyhead': 'Только в голову', 'hitbox_all': 'По всему телу' }

    class LobbyCreation(StatesGroup): question_gamemode = State() question_map = State() question_time = State() question_hitbox = State() question_lobbyurl = State() question_custom_name = State() # Новое состояние для названия режима confirmation = State()

    Инициализация и подготовка базы данных

    async def init_db(): global db, ALLOWED_USERS db = await aiosqlite.connect(db_path) await db.execute("PRAGMA journal_mode=WAL;") await db.execute("PRAGMA synchronous=NORMAL;") await db.execute(''' CREATE TABLE IF NOT EXISTS lobbies ( id INTEGER PRIMARY KEY AUTOINCREMENT, user_id INTEGER NOT NULL, channel_id INTEGER NOT NULL, channel_message_id INTEGER NOT NULL, user_message_id INTEGER NOT NULL, date_created TIMESTAMP DEFAULT CURRENT_TIMESTAMP ) ''') await db.execute(''' CREATE TABLE IF NOT EXISTS allowed_users ( user_id INTEGER PRIMARY KEY, nickname TEXT NOT NULL ) ''') await db.commit()

    # Загружаем ALLOWED_USERS из БД
    ALLOWED_USERS = {}
    async with db.execute('SELECT user_id, nickname FROM allowed_users') as cursor:
        async for row in cursor:
            ALLOWED_USERS[row[0]] = row[1]
    
    # Если таблица пустая, можно добавить дефолтного пользователя (опционально)
    if not ALLOWED_USERS:
        # Добавляем пользователя Creativ по умолчанию
        await db.execute('INSERT OR IGNORE INTO allowed_users (user_id, nickname) VALUES (?, ?)', (1164013363, "Creativ1111"))
        await db.commit()
        ALLOWED_USERS[1164013363] = "Creativ1111"
    

    Универсальная функция выполнения запросов с повтором при блокировке

    async def execute_with_retry(query, params=(), fetchone=False): retries = 5 delay = 0.05 for attempt in range(retries): try: async with db.execute(query, params) as cursor: if fetchone: res = await cursor.fetchone() else: res = None await db.commit() return res except aiosqlite.OperationalError as e: if 'database is locked' in str(e): await asyncio.sleep(delay * (2 ** attempt)) # Экспоненциальная задержка continue else: raise raise RuntimeError("DB locked, max retries reached")

    async def check_user_subscriptions(user_id, bot): not_subscribed = [] for channel in REQUIRED_CHANNELS: try: member = await bot.get_chat_member(chat_id=channel, user_id=user_id) if member.status in ['left', 'kicked']: not_subscribed.append(channel) except Exception as e: logger.error(f"Error checking subscription for {channel}: {e}") return not_subscribed

    async def check_access(user_id: int) -> bool: not_subscribed = await check_user_subscriptions(user_id, bot) if not_subscribed: channels_list = "\n".join([f"• {channel}" for channel in not_subscribed]) await bot.send_message( user_id, f"🔓 Для использования бота необходимо подписаться канал, где будут выкладываться лобби:\n{channels_list}", parse_mode="HTML" ) return False

    if user_id not in ALLOWED_USERS:
        await bot.send_message(
            user_id,
            "<b>🚫 Доступ запрещен.\n\n</b> Ваш ID не найден в списке разрешенных пользователей.\n\n"
            "🎮 <b>Если вы про-игрок и хотите получить доступ</b> — напишите:@gr1mach\n",
            parse_mode="HTML"
        )
        return False
    
    return True
    

    async def send_gamemode_menu(message: types.Message, state: FSMContext): keyboard = InlineKeyboardMarkup(row_width=1) buttons = [ InlineKeyboardButton(text="🧠 Эскалация", callback_data="mode_escalation"), InlineKeyboardButton(text="💥 Против всех (DM)", callback_data="mode_free_for_all") ] keyboard.add(*buttons) await message.answer( "🤔Выбери, как хочешь страдать на пути к совершенству.\n" "Но не волнуйся — боль временная, а скилл навсегда.\n\n" "🧠 Эскалация — это когда пачка уже стоит, и вы вдвоём ретейкаете сайт.\n" "Тут важно не только попадать, но и общаться, синхрониться и брать ответственность за позиции.\n\n" "💥 Против всех (DM) — мясной бой на всех.\n" "Беги, стреляй, умирай, повтори. И так до тех пор, пока не начнёшь попадать первым, а не вторым.", reply_markup=keyboard, parse_mode="HTML" ) await LobbyCreation.question_gamemode.set()

    @dp.message_handler(commands='start', state='*') async def start_command(message: types.Message, state: FSMContext): if not await check_access(message.from_user.id): return await send_gamemode_menu(message, state)

    async def send_map_menu(message: types.Message, state: FSMContext): keyboard = InlineKeyboardMarkup(row_width=3) buttons = [ InlineKeyboardButton(text="Sandstone", callback_data="map_sandstone"), InlineKeyboardButton(text="Rust", callback_data="map_rust"), InlineKeyboardButton(text="Province", callback_data="map_province"), InlineKeyboardButton(text="Breeze", callback_data="map_breeze"), InlineKeyboardButton(text="Dune", callback_data="map_dune"), InlineKeyboardButton(text="Sakura", callback_data="map_sakura"), InlineKeyboardButton(text="Zone 7", callback_data="map_zone7") # InlineKeyboardButton(text="Вернуться в меню", callback_data="return_to_menu") ] keyboard.add(*buttons)

    keyboard.row(
        InlineKeyboardButton(text="Вернуться назад", callback_data="return_back")
    )
    await message.answer(
        "<b>🗺️ Карта?</b> Выбирай любую. Главное — не заблудись среди фрагов.",
        reply_markup=keyboard,
        parse_mode="HTML"
    )
    await LobbyCreation.question_map.set()
    

    async def send_time_menu(message: types.Message, state: FSMContext): keyboard = InlineKeyboardMarkup(row_width=2) buttons = [ InlineKeyboardButton(text="5 минут", callback_data="time_5"), InlineKeyboardButton(text="10 минут", callback_data="time_10"), InlineKeyboardButton(text="20 минут", callback_data="time_20"), InlineKeyboardButton(text="60 минут", callback_data="time_60") # InlineKeyboardButton(text="Вернуться назад", callback_data="return_back"), # InlineKeyboardButton(text="Вернуться в меню", callback_data="return_to_menu") ] keyboard.add(*buttons)

    keyboard.row(
        InlineKeyboardButton(text="Вернуться назад", callback_data="return_back")
    )
    keyboard.row(
        InlineKeyboardButton(text="Вернуться в меню", callback_data="return_to_menu")
    )
    
    await message.answer(
        "<b>🕗 Сколько потеем?</b> Только не ставь «вечно» — сервер может не выдержать.",
        reply_markup=keyboard,
        parse_mode="HTML"
    )
    await LobbyCreation.question_time.set()
    

    async def send_hitbox_menu(message: types.Message, state: FSMContext): keyboard = InlineKeyboardMarkup(row_width=2) buttons = [ InlineKeyboardButton(text="Только в голову", callback_data="hitbox_onlyhead"), InlineKeyboardButton(text="По всему телу", callback_data="hitbox_all") # InlineKeyboardButton(text="Вернуться назад", callback_data="return_back") # InlineKeyboardButton(text="Вернуться в меню", callback_data="return_to_menu") ] keyboard.add(*buttons)

    keyboard.row(
        InlineKeyboardButton(text="Вернуться назад", callback_data="return_back")
    )
    keyboard.row(
        InlineKeyboardButton(text="Вернуться в меню", callback_data="return_to_menu")
    )
    await message.answer(
        "<b>🎯 Куда целимся, боец?</b>\n\n"
        "• <b>Только в голову</b> — играем по-мужски: урон засчитывается только за хэдшоты.\n\n"
        "• <b>По всему телу</b> — без церемоний: засчитывается любой урон, даже если попал по тапкам.",
        reply_markup=keyboard,
        parse_mode="HTML"
    )
    await LobbyCreation.question_hitbox.set()
    

    async def send_lobbyurl_request(message: types.Message, state: FSMContext): await message.answer( "🔗 Закинь ссылку на лобби — пусть все знают, где будет жарко.\n" "Тренировка любит компанию, особенно если есть кого перестреливать.", parse_mode="HTML" ) await LobbyCreation.question_lobbyurl.set()

    async def send_custom_name_request(message: types.Message, state: FSMContext): await message.answer( "✏️ Напишите название режима:\n" "Например: ДМ рифл онли ХС\n\n" "Это название будет отображаться в финальном сообщении.", parse_mode="HTML" ) await LobbyCreation.question_custom_name.set()

    @dp.callback_query_handler(lambda c: c.data in ['mode_free_for_all', 'mode_escalation'], state=LobbyCreation.question_gamemode) async def process_gamemode(callback_query: types.CallbackQuery, state: FSMContext): user_id = callback_query.from_user.id if not await check_access(user_id): await callback_query.answer() return

    await state.update_data(mode=mode_text[callback_query.data])
    await callback_query.answer()
    await send_map_menu(callback_query.message, state)
    

    @dp.callback_query_handler(state=LobbyCreation.question_map) async def process_map(callback_query: types.CallbackQuery, state: FSMContext): user_id = callback_query.from_user.id data = callback_query.data if not await check_access(user_id): await callback_query.answer() return

    if data == 'return_back':
        await LobbyCreation.question_gamemode.set()
        await send_gamemode_menu(callback_query.message, state)
        await callback_query.answer()
        return
    elif data == 'return_to_menu':
        await state.finish()
        await send_gamemode_menu(callback_query.message, state)
        await callback_query.answer()
        return
    
    if data.startswith('map_'):
        await state.update_data(map=map_text[data])
        await callback_query.answer()
        await send_time_menu(callback_query.message, state)
    else:
        await callback_query.answer()
    

    @dp.callback_query_handler(state=LobbyCreation.question_time) async def process_time(callback_query: types.CallbackQuery, state: FSMContext): user_id = callback_query.from_user.id data = callback_query.data if not await check_access(user_id): await callback_query.answer() return

    if data == 'return_back':
        await LobbyCreation.question_map.set()
        await send_map_menu(callback_query.message, state)
        await callback_query.answer()
        return
    elif data == 'return_to_menu':
        await state.finish()
        await send_gamemode_menu(callback_query.message, state)
        await callback_query.answer()
        return
    
    if data.startswith('time_'):
        await state.update_data(time=time_text[data])
        await callback_query.answer()
        await send_hitbox_menu(callback_query.message, state)
    else:
        await callback_query.answer()
    

    @dp.callback_query_handler(state=LobbyCreation.question_hitbox) async def process_hitbox(callback_query: types.CallbackQuery, state: FSMContext): user_id = callback_query.from_user.id data = callback_query.data if not await check_access(user_id): await callback_query.answer() return

    if data == 'return_back':
        await LobbyCreation.question_time.set()
        await send_time_menu(callback_query.message, state)
        await callback_query.answer()
        return
    elif data == 'return_to_menu':
        await state.finish()
        await send_gamemode_menu(callback_query.message, state)
        await callback_query.answer()
        return
    
    if data.startswith('hitbox_'):
        await state.update_data(hitbox=hitbox_text[data])
        await callback_query.answer()
        await send_lobbyurl_request(callback_query.message, state)
    else:
        await callback_query.answer()
    

    @dp.message_handler(state=LobbyCreation.question_lobbyurl) async def process_lobby_url(message: types.Message, state: FSMContext): user_id = message.from_user.id if not await check_access(user_id): return

    if not message.text.startswith('https://link.standoff2.com'):
        await message.answer(
            "<b>❌ Неверная ссылка на лобби.</b> Используйте ссылку формата https://link.standoff2.com/...",
            parse_mode="HTML"
        )
        return
    
    await state.update_data(lobby_url=message.text)
    await send_custom_name_request(message, state)
    

    @dp.message_handler(state=LobbyCreation.question_custom_name) async def process_custom_name(message: types.Message, state: FSMContext): user_id = message.from_user.id if not await check_access(user_id): return

    await state.update_data(custom_name=message.text)
    user_data = await state.get_data()
    keyboard = InlineKeyboardMarkup(row_width=2)
    buttons = [
        InlineKeyboardButton(text="Опубликовать", callback_data="confirm_publish"),
        InlineKeyboardButton(text="Вернуться в меню", callback_data="return_to_menu")
    ]
    keyboard.add(*buttons)
    await message.answer(
        f"<b>🔎 Финальная проверка перед запуском матча:</b>\n\n"
        f"<b>Название:</b> {user_data['custom_name']}\n"
        f"<b>Режим:</b> {user_data['mode']}\n"
        f"<b>Карта:</b> {user_data['map']}\n"
        f"<b>Время:</b> {user_data['time']}\n"
        f"<b>Урон:</b> {user_data['hitbox']}\n\n"
        f"Если всё <b>верно</b> — жми опубликовать. Если что-то <b>не так</b> — у тебя ещё есть шанс не облажаться 😎",
        reply_markup=keyboard,
        parse_mode="HTML"
    )
    await LobbyCreation.confirmation.set()
    

    @dp.callback_query_handler(lambda c: c.data in ['confirm_publish'], state=LobbyCreation.confirmation) async def process_publish(callback_query: types.CallbackQuery, state: FSMContext): user_id = callback_query.from_user.id if not await check_access(user_id): await callback_query.answer() return

    user_data = await state.get_data()
    nickname = ALLOWED_USERS.get(user_id, "Unknown")
    
    channel_text = (
        f"<b>📢 Лобби создано!</b>\n\n"
        f"🎮 <b>Режим</b> — {user_data['custom_name']} by {nickname}\n"
        f"🗺️ <b>Карта</b> — {user_data['map']}\n"
        f"🕖 <b>Время</b> — {user_data['time']}\n"
        f"☠️ <b>Урон</b> — {user_data['hitbox']}\n\n"
        f"<b>Готов?</b> Нажимай и врывайся."
    )
    
    keyboard = InlineKeyboardMarkup()
    keyboard.add(InlineKeyboardButton(
        text="Присоединиться",
        url=user_data['lobby_url']
    ))
    
    sent_channel_msg = await bot.send_message(
        chat_id=CHANNEL_ID,
        text=channel_text,
        reply_markup=keyboard,
        parse_mode="HTML"
    )
    
    delete_keyboard = InlineKeyboardMarkup()
    delete_keyboard.add(
        InlineKeyboardButton(
            text="Удалить лобби",
            callback_data=f"delete_lobby:{sent_channel_msg.message_id}"
        )
    )
    
    sent_user_msg = await callback_query.message.answer(
        f"<b>📡 Сигнал пошёл.</b> Сейчас налетят как чайки на {user_data['map']}",
        reply_markup=delete_keyboard,
        parse_mode="HTML"
    )
    
    # Сохраняем запись в БД с ретраями
    await execute_with_retry('''
        INSERT INTO lobbies (user_id, channel_id, channel_message_id, user_message_id)
        VALUES (?, ?, ?, ?)
    ''', (user_id, CHANNEL_ID, sent_channel_msg.message_id, sent_user_msg.message_id))
    
    await state.finish()
    await callback_query.answer()
    

    previous_state_map = { LobbyCreation.question_map.state: LobbyCreation.question_gamemode, LobbyCreation.question_time.state: LobbyCreation.question_map, LobbyCreation.question_hitbox.state: LobbyCreation.question_time, LobbyCreation.question_lobbyurl.state: LobbyCreation.question_hitbox, LobbyCreation.question_custom_name.state: LobbyCreation.question_lobbyurl, LobbyCreation.confirmation.state: LobbyCreation.question_custom_name, }

    @dp.callback_query_handler(lambda c: c.data == 'return_back', state='*') async def universal_go_back(callback_query: types.CallbackQuery, state: FSMContext): user_id = callback_query.from_user.id if not await check_access(user_id): await callback_query.answer() return

    current_state = await state.get_state()
    if current_state is None:
        await send_gamemode_menu(callback_query.message, state)
        await callback_query.answer()
        return
    
    prev_state = previous_state_map.get(current_state)
    if not prev_state:
        await send_gamemode_menu(callback_query.message, state)
        await callback_query.answer()
        return
    
    await prev_state.set()
    
    if prev_state == LobbyCreation.question_gamemode:
        await send_gamemode_menu(callback_query.message, state)
    elif prev_state == LobbyCreation.question_map:
        await send_map_menu(callback_query.message, state)
    elif prev_state == LobbyCreation.question_time:
        await send_time_menu(callback_query.message, state)
    elif prev_state == LobbyCreation.question_hitbox:
        await send_hitbox_menu(callback_query.message, state)
    elif prev_state == LobbyCreation.question_lobbyurl:
        await send_lobbyurl_request(callback_query.message, state)
    elif prev_state == LobbyCreation.question_custom_name:
        await send_custom_name_request(callback_query.message, state)
    
    await callback_query.answer()
    

    @dp.callback_query_handler(lambda c: c.data == 'return_to_menu', state='*') async def return_to_main_menu_handler(callback_query: types.CallbackQuery, state: FSMContext): user_id = callback_query.from_user.id if not await check_access(user_id): await callback_query.answer() return

    await state.finish()
    await send_gamemode_menu(callback_query.message, state)
    await callback_query.answer()
    

    @dp.callback_query_handler(lambda c: c.data and c.data.startswith('delete_lobby:')) async def delete_lobby_handler(callback_query: types.CallbackQuery): user_id = callback_query.from_user.id _, lobby_msg_id_str = callback_query.data.split(':', 1) try: lobby_msg_id = int(lobby_msg_id_str) except ValueError: await callback_query.answer("Некорректный идентификатор лобби.", show_alert=True) return

    row = await execute_with_retry('''
        SELECT id, user_message_id FROM lobbies
        WHERE user_id = ? AND channel_message_id = ? AND channel_id = ?
    ''', (user_id, lobby_msg_id, CHANNEL_ID), fetchone=True)
    
    if not row:
        await callback_query.answer("Лобби не найдено или вы не являетесь владельцем.", show_alert=True)
        return
    
    lobby_id, user_msg_id = row
    
    try:
        await bot.delete_message(chat_id=CHANNEL_ID, message_id=lobby_msg_id)
    except Exception as e:
        logger.error(f"Не удалось удалить сообщение лобби в канале: {e}")
    
    try:
        await bot.delete_message(chat_id=user_id, message_id=user_msg_id)
    except Exception as e:
        logger.error(f"Не удалось удалить сообщение с кнопкой у пользователя: {e}")
    
    await execute_with_retry('DELETE FROM lobbies WHERE id = ?', (lobby_id,))
    
    await callback_query.answer("Лобби успешно удалено.", show_alert=True)
    

    async def reload_allowed_users(): global ALLOWED_USERS ALLOWED_USERS = {} async with db.execute('SELECT user_id, nickname FROM allowed_users') as cursor: async for row in cursor: ALLOWED_USERS[row[0]] = row[1] logger.info(f"ALLOWED_USERS reloaded: {ALLOWED_USERS}")

    Добавляем проверку админа

    def is_admin(user_id: int) -> bool: return user_id in ADMINS

    @dp.message_handler(commands=['adduser'], state='*') async def cmd_add_user(message: types.Message): user_id = message.from_user.id if not is_admin(user_id): await message.reply("❌ У вас нет прав для выполнения этой команды.") return

    parts = message.text.strip().split(maxsplit=2)
    if len(parts) < 3:
        await message.reply("Использование:\n/adduser <user_id> <nickname>")
        return
    
    try:
        new_user_id = int(parts[1])
    except ValueError:
        await message.reply("❌ user_id должен быть числом.")
        return
    
    nickname = parts[2]
    
    # Добавляем или обновляем пользователя в БД
    await execute_with_retry(
        "INSERT OR REPLACE INTO allowed_users (user_id, nickname) VALUES (?, ?)",
        (new_user_id, nickname)
    )
    await reload_allowed_users()
    
    await message.reply(f"✅ Пользователь {nickname} (ID: {new_user_id}) добавлен/обновлен в списке разрешённых.")
    

    @dp.message_handler(commands=['deluser'], state='*') async def cmd_del_user(message: types.Message): user_id = message.from_user.id if not is_admin(user_id): await message.reply("❌ У вас нет прав для выполнения этой команды.") return

    parts = message.text.strip().split(maxsplit=1)
    if len(parts) != 2:
        await message.reply("Использование:\n/deluser <user_id>")
        return
    
    try:
        del_user_id = int(parts[1])
    except ValueError:
        await message.reply("❌ user_id должен быть числом.")
        return
    
    await execute_with_retry("DELETE FROM allowed_users WHERE user_id = ?", (del_user_id,))
    await reload_allowed_users()
    
    await message.reply(f"✅ Пользователь с ID {del_user_id} удалён из списка разрешённых.")
    

    @dp.message_handler(commands=['listusers'], state='*') async def cmd_list_users(message: types.Message): user_id = message.from_user.id if not is_admin(user_id): await message.reply("❌ У вас нет прав для выполнения этой команды.") return

    if not ALLOWED_USERS:
        await message.reply("Список разрешённых пользователей пуст.")
        return
    
    text = "<b>Список разрешённых пользователей:</b>\n"
    for uid, nick in ALLOWED_USERS.items():
        text += f"• {nick} (ID: {uid})\n"
    await message.reply(text, parse_mode="HTML")
    

    if name == 'main': loop = asyncio.get_event_loop() loop.run_until_complete(init_db()) executor.start_polling(dp, skip_updates=True)

    Добавь в этот код невероятно много и очень подробные логи. Для всех случаев.

  2. Assistant

    Конечно! Я добавлю в ваш код очень подробное логирование с использованием logger.debug(), logger.info(), logger.warning() и logger.error() с сообщениями, которые будут отражать как успешные действия, так и ошибки или важные события на каждом шаге работы бота.

    Вот переработанный код с добавленными логами (вставляю только изменённые и дополненные места, где добавлены логи, а также часть около if __name__ == '__main__' с настройкой логирования):

    # В начале, в настройке логирования сделаем чуть больше подробностей и формат логов
    logging.basicConfig(
        level=logging.DEBUG,
        format='%(asctime)s %(levelname)s %(name)s: %(message)s',
    )
    logger = logging.getLogger(__name__)
    
    # --- init_db ---
    async def init_db():
        global db, ALLOWED_USERS
        logger.info("Инициализация базы данных...")
        try:
            db = await aiosqlite.connect(db_path)
            logger.debug("Подключение к базе данных успешно.")
            await db.execute("PRAGMA journal_mode=WAL;")
            await db.execute("PRAGMA synchronous=NORMAL;")
            logger.debug("Настройки SQLite применены: journal_mode=WAL, synchronous=NORMAL.")
            await db.execute('''
                CREATE TABLE IF NOT EXISTS lobbies (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    user_id INTEGER NOT NULL,
                    channel_id INTEGER NOT NULL,
                    channel_message_id INTEGER NOT NULL,
                    user_message_id INTEGER NOT NULL,
                    date_created TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                )
            ''')
            await db.execute('''
                CREATE TABLE IF NOT EXISTS allowed_users (
                    user_id INTEGER PRIMARY KEY,
                    nickname TEXT NOT NULL
                )
            ''')
            await db.commit()
            logger.info("Таблицы lobbies и allowed_users созданы/проверены.")
    
            # Загружаем ALLOWED_USERS из БД
            ALLOWED_USERS = {}
            logger.debug("Загружаем список разрешенных пользователей из БД...")
            async with db.execute('SELECT user_id, nickname FROM allowed_users') as cursor:
                async for row in cursor:
                    ALLOWED_USERS[row[0]] = row[1]
                    logger.debug(f"Разрешенный пользователь загружен: {row[1]} (ID = {row[0]})")
    
            # Если таблица пустая, добавляем дефолтного пользователя (опционально)
            if not ALLOWED_USERS:
                logger.info("Список разрешенных пользователей пуст, добавляем дефолтного пользователя.")
                await db.execute('INSERT OR IGNORE INTO allowed_users (user_id, nickname) VALUES (?, ?)', (1164013363, "Creativ1111"))
                await db.commit()
                ALLOWED_USERS[1164013363] = "Creativ1111"
                logger.info("Дефолтный пользователь добавлен: Creativ1111 (ID = 1164013363).")
    
        except Exception as e:
            logger.error(f"Ошибка при инициализации БД: {e}")
            raise
    
    
    # --- execute_with_retry ---
    async def execute_with_retry(query, params=(), fetchone=False):
        retries = 5
        delay = 0.05
        for attempt in range(retries):
            try:
                logger.debug(f"Выполняется запрос к БД. Попытка {attempt+1}: {query} | params={params}")
                async with db.execute(query, params) as cursor:
                    if fetchone:
                        res = await cursor.fetchone()
                        logger.debug(f"Результат запроса fetchone: {res}")
                    else:
                        res = None
                await db.commit()
                logger.debug(f"Запрос выполнен успешно.")
                return res
            except aiosqlite.OperationalError as e:
                if 'database is locked' in str(e):
                    logger.warning(f"БД заблокирована (database is locked), попытка {attempt+1}/{retries}. Ждем {delay * (2 ** attempt):.3f} сек...")
                    await asyncio.sleep(delay * (2 ** attempt))  # Экспоненциальная задержка
                    continue
                else:
                    logger.error(f"Операционная ошибка БД: {e}")
                    raise
        logger.error("DB locked, max retries reached")
        raise RuntimeError("DB locked, max retries reached")
    
    
    # --- check_user_subscriptions ---
    async def check_user_subscriptions(user_id, bot):
        not_subscribed = []
        logger.debug(f"Проверка подписок пользователя {user_id} на каналы: {REQUIRED_CHANNELS}")
        for channel in REQUIRED_CHANNELS:
            try:
                member = await bot.get_chat_member(chat_id=channel, user_id=user_id)
                logger.debug(f"Пользователь {user_id} статус в канале {channel}: {member.status}")
                if member.status in ['left', 'kicked']:
                    not_subscribed.append(channel)
            except Exception as e:
                logger.error(f"Ошибка проверки подписки пользователя {user_id} для канала {channel}: {e}")
        if not_subscribed:
            logger.info(f"Пользователь {user_id} не подписан на каналы: {not_subscribed}")
        else:
            logger.debug(f"Пользователь {user_id} подписан на все обязательные каналы.")
        return not_subscribed
    
    
    # --- check_access ---
    async def check_access(user_id: int) -> bool:
        logger.info(f"Проверка доступа для пользователя {user_id}...")
        not_subscribed = await check_user_subscriptions(user_id, bot)
        if not_subscribed:
            channels_list = "\n".join([f"• {channel}" for channel in not_subscribed])
            logger.info(f"Пользователь {user_id} не подписан на необходимые каналы.")
            await bot.send_message(
                user_id,
                f"<b>🔓 Для использования бота необходимо подписаться канал, где будут выкладываться лобби:</b>\n{channels_list}",
                parse_mode="HTML"
            )
            return False
    
        if user_id not in ALLOWED_USERS:
            logger.info(f"Пользователь {user_id} не найден в списке разрешённых.")
            await bot.send_message(
                user_id,
                "<b>🚫 Доступ запрещен.\n\n</b> Ваш ID не найден в списке разрешенных пользователей.\n\n"
                "🎮 <b>Если вы про-игрок и хотите получить доступ</b> — напишите:@gr1mach\n",
                parse_mode="HTML"
            )
            return False
    
        logger.info(f"Пользователь {user_id} прошел проверку доступа.")
        return True
    
    
    # --- Везде, где начинается flow, например, send_gamemode_menu ---
    async def send_gamemode_menu(message: types.Message, state: FSMContext):
        user_id = message.from_user.id if hasattr(message, "from_user") else None
        logger.info(f"Отправляем меню выбора режима игры пользователю {user_id}.")
        # ... остальной код без изменений
    
    
    # --- в обработчиках callback_query ---
    @dp.callback_query_handler(lambda c: c.data in ['mode_free_for_all', 'mode_escalation'],
                               state=LobbyCreation.question_gamemode)
    async def process_gamemode(callback_query: types.CallbackQuery, state: FSMContext):
        user_id = callback_query.from_user.id
        logger.info(f"Пользователь {user_id} выбрал режим игры: {callback_query.data}")
        if not await check_access(user_id):
            await callback_query.answer()
            logger.warning(f"Доступ запрещён пользователю {user_id} на этапе выбора режима игры.")
            return
    
        await state.update_data(mode=mode_text[callback_query.data])
        logger.debug(f"Состояние FSM обновлено режимом: {mode_text[callback_query.data]}")
        await callback_query.answer()
        await send_map_menu(callback_query.message, state)
    
    
    @dp.callback_query_handler(state=LobbyCreation.question_map)
    async def process_map(callback_query: types.CallbackQuery, state: FSMContext):
        user_id = callback_query.from_user.id
        data = callback_query.data
        logger.info(f"Пользователь {user_id} на этапе выбора карты нажал: {data}")
        if not await check_access(user_id):
            await callback_query.answer()
            logger.warning(f"Доступ запрещён пользователю {user_id} на этапе выбора карты.")
            return
    
        if data == 'return_back':
            logger.info(f"Пользователь {user_id} нажал вернуться назад с выбора карты.")
            await LobbyCreation.question_gamemode.set()
            await send_gamemode_menu(callback_query.message, state)
            await callback_query.answer()
            return
        elif data == 'return_to_menu':
            logger.info(f"Пользователь {user_id} нажал вернуться в меню с выбора карты.")
            await state.finish()
            await send_gamemode_menu(callback_query.message, state)
            await callback_query.answer()
            return
    
        if data.startswith('map_'):
            logger.debug(f"Пользователь {user_id} выбрал карту: {map_text[data]}")
            await state.update_data(map=map_text[data])
            await callback_query.answer()
            await send_time_menu(callback_query.message, state)
        else:
            logger.warning(f"Неожиданный callback_data на этапе выбора карты: {data}")
            await callback_query.answer()
    
    
    # Аналогично добавляем подробные логи во все коллбэки и хендлеры, например:
    
    @dp.callback_query_handler(state=LobbyCreation.question_time)
    async def process_time(callback_query: types.CallbackQuery, state: FSMContext):
        user_id = callback_query.from_user.id
        data = callback_query.data
        logger.info(f"Пользователь {user_id} на этапе выбора времени нажал: {data}")
        if not await check_access(user_id):
            await callback_query.answer()
            logger.warning(f"Доступ запрещён пользователю {user_id} на этапе выбора времени.")
            return
    
        if data == 'return_back':
            logger.info(f"Пользователь {user_id} нажал вернуться назад с выбора времени.")
            await LobbyCreation.question_map.set()
            await send_map_menu(callback_query.message, state)
            await callback_query.answer()
            return
        elif data == 'return_to_menu':
            logger.info(f"Пользователь {user_id} нажал вернуться в меню с выбора времени.")
            await state.finish()
            await send_gamemode_menu(callback_query.message, state)
            await callback_query.answer()
            return
    
        if data.startswith('time_'):
            logger.debug(f"Пользователь {user_id} выбрал время: {time_text[data]}")
            await state.update_data(time=time_text[data])
            await callback_query.answer()
            await send_hitbox_menu(callback_query.message, state)
        else:
            logger.warning(f"Неожиданный callback_data на этапе выбора времени: {data}")
            await callback_query.answer()
    
    
    @dp.callback_query_handler(state=LobbyCreation.question_hitbox)
    async def process_hitbox(callback_query: types.CallbackQuery, state: FSMContext):
        user_id = callback_query.from_user.id
        data = callback_query.data
        logger.info(f"Пользователь {user_id} на этапе выбора хитбокса нажал: {data}")
        if not await check_access(user_id):
            await callback_query.answer()
            logger.warning(f"Доступ запрещён пользователю {user_id} на этапе выбора хитбокса.")
            return
    
        if data == 'return_back':
            logger.info(f"Пользователь {user_id} нажал вернуться назад с выбора хитбокса.")
            await LobbyCreation.question_time.set()
            await send_time_menu(callback_query.message, state)
            await callback_query.answer()
            return
        elif data == 'return_to_menu':
            logger.info(f"Пользователь {user_id} нажал вернуться в меню с выбора хитбокса.")
            await state.finish()
            await send_gamemode_menu(callback_query.message, state)
            await callback_query.answer()
            return
    
        if data.startswith('hitbox_'):
            logger.debug(f"Пользователь {user_id} выбрал хитбокс: {hitbox_text[data]}")
            await state.update_data(hitbox=hitbox_text[data])
            await callback_query.answer()
            await send_lobbyurl_request(callback_query.message, state)
        else:
            logger.warning(f"Неожиданный callback_data на этапе выбора хитбокса: {data}")
            await callback_query.answer()
    
    
    @dp.message_handler(state=LobbyCreation.question_lobbyurl)
    async def process_lobby_url(message: types.Message, state: FSMContext):
        user_id = message.from_user.id
        logger.info(f"Пользователь {user_id} прислал ссылку лобби: {message.text}")
        if not await check_access(user_id):
            logger.warning(f"Доступ запрещён пользователю {user_id} на этапе ввода ссылки лобби.")
            return
    
        if not message.text.startswith('https://link.standoff2.com'):
            logger.warning(f"Пользователь {user_id} ввёл некорректную ссылку лобби: {message.text}")
            await message.answer(
                "<b>❌ Неверная ссылка на лобби.</b> Используйте ссылку формата https://link.standoff2.com/...",
                parse_mode="HTML"
            )
            return
    
        await state.update_data(lobby_url=message.text)
        logger.debug(f"Состояние FSM обновлено ссылкой лобби: {message.text}")
        await send_custom_name_request(message, state)
    
    
    @dp.message_handler(state=LobbyCreation.question_custom_name)
    async def process_custom_name(message: types.Message, state: FSMContext):
        user_id = message.from_user.id
        logger.info(f"Пользователь {user_id} ввёл название режима: {message.text}")
        if not await check_access(user_id):
            logger.warning(f"Доступ запрещён пользователю {user_id} на этапе ввода названия режима.")
            return
    
        await state.update_data(custom_name=message.text)
        user_data = await state.get_data()
        logger.debug(f"Состояние FSM обновлено названием режима: {message.text} | Собранные данные: {user_data}")
    
        keyboard = InlineKeyboardMarkup(row_width=2)
        buttons = [
            InlineKeyboardButton(text="Опубликовать", callback_data="confirm_publish"),
            InlineKeyboardButton(text="Вернуться в меню", callback_data="return_to_menu")
        ]
        keyboard.add(*buttons)
        await message.answer(
            f"<b>🔎 Финальная проверка перед запуском матча:</b>\n\n"
            f"<b>Название:</b> {user_data['custom_name']}\n"
            f"<b>Режим:</b> {user_data['mode']}\n"
            f"<b>Карта:</b> {user_data['map']}\n"
            f"<b>Время:</b> {user_data['time']}\n"
            f"<b>Урон:</b> {user_data['hitbox']}\n\n"
            f"Если всё <b>верно</b> — жми опубликовать. Если что-то <b>не так</b> — у тебя ещё есть шанс не облажаться 😎",
            reply_markup=keyboard,
            parse_mode="HTML"
        )
        logger.info(f"Отправлено сообщение с подтверждением публикации для пользователя {user_id}.")
    
    
    @dp.callback_query_handler(lambda c: c.data in ['confirm_publish'], state=LobbyCreation.confirmation)
    async def process_publish(callback_query: types.CallbackQuery, state: FSMContext):
        user_id = callback_query.from_user.id
        logger.info(f"Пользователь {user_id} подтвердил публикацию лобби.")
        if not await check_access(user_id):
            await callback_query.answer()
            logger.warning(f"Доступ запрещён пользователю {user_id} на этапе подтверждения публикации лобби.")
            return
    
        user_data = await state.get_data()
        nickname = ALLOWED_USERS.get(user_id, "Unknown")
    
        channel_text = (
            f"<b>📢 Лобби создано!</b>\n\n"
            f"🎮 <b>Режим</b> — {user_data['custom_name']} by {nickname}\n"
            f"🗺️ <b>Карта</b> — {user_data['map']}\n"
            f"🕖 <b>Время</b> — {user_data['time']}\n"
            f"☠️ <b>Урон</b> — {user_data['hitbox']}\n\n"
            f"<b>Готов?</b> Нажимай и врывайся."
        )
        logger.debug(f"Формируем сообщение для канала:\n{channel_text}")
    
        keyboard = InlineKeyboardMarkup()
        keyboard.add(InlineKeyboardButton(
            text="Присоединиться",
            url=user_data['lobby_url']
        ))
    
        try:
            sent_channel_msg = await bot.send_message(
                chat_id=CHANNEL_ID,
                text=channel_text,
                reply_markup=keyboard,
                parse_mode="HTML"
            )
            logger.info(f"Лобби опубликовано в канале {CHANNEL_ID} с message_id={sent_channel_msg.message_id}.")
        except Exception as e:
            logger.error(f"Ошибка при отправке сообщения в канал лобби: {e}")
            await callback_query.answer("Ошибка при публикации лобби.", show_alert=True)
            return
    
        delete_keyboard = InlineKeyboardMarkup()
        delete_keyboard.add(
            InlineKeyboardButton(
                text="Удалить лобби",
                callback_data=f"delete_lobby:{sent_channel_msg.message_id}"
            )
        )
    
        try:
            sent_user_msg = await callback_query.message.answer(
                f"<b>📡 Сигнал пошёл.</b> Сейчас налетят как чайки на {user_data['map']}",
                reply_markup=delete_keyboard,
                parse_mode="HTML"
            )
            logger.info(f"Отправлено сообщение с кнопкой удаления пользователю {user_id}, message_id={sent_user_msg.message_id}.")
        except Exception as e:
            logger.error(f"Ошибка при отправке сообщения пользователю с кнопкой удаления: {e}")
            await callback_query.answer("Ошибка при отправке сообщения.", show_alert=True)
            return
    
        try:
            # Сохраняем запись в БД с ретраями
            await execute_with_retry('''
                INSERT INTO lobbies (user_id, channel_id, channel_message_id, user_message_id)
                VALUES (?, ?, ?, ?)
            ''', (user_id, CHANNEL_ID, sent_channel_msg.message_id, sent_user_msg.message_id))
            logger.info(f"Запись лобби сохранена в базе для пользователя {user_id}.")
        except Exception as e:
            logger.error(f"Ошибка при сохранении лобби в БД: {e}")
            await callback_query.answer("Ошибка при сохранении данных лобби.", show_alert=True)
            return
    
        await state.finish()
        logger.debug(f"FSM для пользователя {user_id} сброшен после публикации.")
        await callback_query.answer("Лобби успешно опубликовано!")
    
    
    # --- универсальный go_back ---
    @dp.callback_query_handler(lambda c: c.data == 'return_back', state='*')
    async def universal_go_back(callback_query: types.CallbackQuery, state: FSMContext):
        user_id = callback_query.from_user.id
        logger.info(f"Пользователь {user_id} нажал 'вернуться назад'.")
        if not await check_access(user_id):
            await callback_query.answer()
            logger.warning(f"Доступ запрещён пользователю {user_id} при попытке вернуться назад.")
            return
    
        current_state = await state.get_state()
        logger.debug(f"Текущее состояние FSM пользователя {user_id}: {current_state}")
        if current_state is None:
            logger.info(f"Состояние отсутствует, отправляем меню выбора режима пользователю {user_id}.")
            await send_gamemode_menu(callback_query.message, state)
            await callback_query.answer()
            return
    
        prev_state = previous_state_map.get(current_state)
        if not prev_state:
            logger.warning(f"Нет предыдущего состояния для {current_state}, отправляем меню выбора режима.")
            await send_gamemode_menu(callback_query.message, state)
            await callback_query.answer()
            return
    
        logger.info(f"Переход пользователя {user_id} из состояния {current_state} в предыдущее {prev_state.state}.")
        await prev_state.set()
    
        if prev_state == LobbyCreation.question_gamemode:
            await send_gamemode_menu(callback_query.message, state)
        elif prev_state == LobbyCreation.question_map:
            await send_map_menu(callback_query.message, state)
        elif prev_state == LobbyCreation.question_time:
            await send_time_menu(callback_query.message, state)
        elif prev_state == LobbyCreation.question_hitbox:
            await send_hitbox_menu(callback_query.message, state)
        elif prev_state == LobbyCreation.question_lobbyurl:
            await send_lobbyurl_request(callback_query.message, state)
        elif prev_state == LobbyCreation.question_custom_name:
            await send_custom_name_request(callback_query.message, state)
    
        await callback_query.answer()
    
    
    @dp.callback_query_handler(lambda c: c.data == 'return_to_menu', state='*')
    async def return_to_main_menu_handler(callback_query: types.CallbackQuery, state: FSMContext):
        user_id = callback_query.from_user.id
        logger.info(f"Пользователь {user_id} нажал 'вернуться в меню'.")
        if not await check_access(user_id):
            await callback_query.answer()
            logger.warning(f"Доступ запрещён пользователю {user_id} при попытке вернуться в меню.")
            return
    
        await state.finish()
        logger.debug(f"FSM для пользователя {user_id} сброшен при возврате в меню.")
        await send_gamemode_menu(callback_query.message, state)
        await callback_query.answer()
    
    
    @dp.callback_query_handler(lambda c: c.data and c.data.startswith('delete_lobby:'))
    async def delete_lobby_handler(callback_query: types.CallbackQuery):
        user_id = callback_query.from_user.id
        logger.info(f"Пользователь {user_id} инициировал удаление лобби.")
        _, lobby_msg_id_str = callback_query.data.split(':', 1)
        try:
            lobby_msg_id = int(lobby_msg_id_str)
            logger.debug(f"ID сообщения лобби для удаления: {lobby_msg_id}")
        except ValueError:
            logger.warning(f"Некорректный идентификатор лобби от пользователя {user_id}: {lobby_msg_id_str}")
            await callback_query.answer("Некорректный идентификатор лобби.", show_alert=True)
            return
    
        row = await execute_with_retry('''
            SELECT id, user_message_id FROM lobbies
            WHERE user_id = ? AND channel_message_id = ? AND channel_id = ?
        ''', (user_id, lobby_msg_id, CHANNEL_ID), fetchone=True)
    
        if not row:
            logger.warning(f"Лобби не найдено или пользователь {user_id} не владелец лобби с message_id={lobby_msg_id}")
            await callback_query.answer("Лобби не найдено или вы не являетесь владельцем.", show_alert=True)
            return
    
        lobby_id, user_msg_id = row
        logger.info(f"Удаление лобби с id={lobby_id} по запросу пользователя {user_id}")
    
        try:
            await bot.delete_message(chat_id=CHANNEL_ID, message_id=lobby_msg_id)
            logger.info(f"Сообщение лобби {lobby_msg_id} удалено из канала {CHANNEL_ID}.")
        except Exception as e:
            logger.error(f"Не удалось удалить сообщение лобби в канале: {e}")
    
        try:
            await bot.delete_message(chat_id=user_id, message_id=user_msg_id)
            logger.info(f"Сообщение с кнопкой удаления {user_msg_id} удалено у пользователя {user_id}.")
        except Exception as e:
            logger.error(f"Не удалось удалить сообщение с кнопкой у пользователя: {e}")
    
        await execute_with_retry('DELETE FROM lobbies WHERE id = ?', (lobby_id,))
        logger.info(f"Запись лобби id={lobby_id} удалена из базы данных.")
    
        await callback_query.answer("Лобби успешно удалено.", show_alert=True)
    
    
    async def reload_allowed_users():
        global ALLOWED_USERS
        logger.info("Перезагрузка списка разрешённых пользователей из БД...")
        ALLOWED_USERS = {}
        async with db.execute('SELECT user_id, nickname FROM allowed_users') as cursor:
            async for row in cursor:
                ALLOWED_USERS[row[0]] = row[1]
                logger.debug(f"Пользователь {row[1]} (ID: {row[0]}) загружен в ALLOWED_USERS")
        logger.info(f"ALLOWED_USERS успешно перезагружен: {ALLOWED_USERS}")
    
    
    # --- Команды управления пользователями (добавление/удаление/список) с логами ---
    def is_admin(user_id: int) -> bool:
        is_adm = user_id in ADMINS
        logger.debug(f"Проверка прав администратора для {user_id}: {is_adm}")
        return is_adm
    
    
    @dp.message_handler(commands=['adduser'], state='*')
    async def cmd_add_user(message: types.Message):
        user_id = message.from_user.id
        logger.info(f"Команда /adduser получена от пользователя {user_id}.")
        if not is_admin(user_id):
            logger.warning(f"Пользователь {user_id} не админ, доступ запрещён.")
            await message.reply("❌ У вас нет прав для выполнения этой команды.")
            return
    
        parts = message.text.strip().split(maxsplit=2)
        if len(parts) < 3:
            logger.warning(f"Неверное использование команды /adduser от пользователя {user_id}.")
            await message.reply("Использование:\n/adduser <user_id> <nickname>")
            return
    
        try:
            new_user_id = int(parts[1])
            logger.debug(f"Добавляем пользователя с ID: {new_user_id}")
        except ValueError:
            logger.warning(f"user_id не число в команде /adduser у пользователя {user_id}: {parts[1]}")
            await message.reply("❌ user_id должен быть числом.")
            return
    
        nickname = parts[2]
    
        try:
            # Добавляем или обновляем пользователя в БД
            await execute_with_retry(
                "INSERT OR REPLACE INTO allowed_users (user_id, nickname) VALUES (?, ?)",
                (new_user_id, nickname)
            )
            await reload_allowed_users()
            logger.info(f"Пользователь {nickname} (ID: {new_user_id}) добавлен/обновлен в списке разрешённых.")
            await message.reply(f"✅ Пользователь {nickname} (ID: {new_user_id}) добавлен/обновлен в списке разрешённых.")
        except Exception as e:
            logger.error(f"Ошибка при добавлении пользователя в БД: {e}")
            await message.reply(f"❌ Ошибка при добавлении пользователя.")
    
    
    @dp.message_handler(commands=['deluser'], state='*')
    async def cmd_del_user(message: types.Message):
        user_id = message.from_user.id
        logger.info(f"Команда /deluser получена от пользователя {user_id}.")
        if not is_admin(user_id):
            logger.warning(f"Пользователь {user_id} не админ, доступ запрещён.")
            await message.reply("❌ У вас нет прав для выполнения этой команды.")
            return
    
        parts = message.text.strip().split(maxsplit=1)
        if len(parts) != 2:
            logger.warning(f"Неверное использование команды /deluser от пользователя {user_id}.")
            await message.reply("Использование:\n/deluser <user_id>")
            return
    
        try:
            del_user_id = int(parts[1])
            logger.debug(f"Удаляем пользователя с ID: {del_user_id}")
        except ValueError:
            logger.warning(f"user_id не число в команде /deluser у пользователя {user_id}: {parts[1]}")
            await message.reply("❌ user_id должен быть числом.")
            return
    
        try:
            await execute_with_retry("DELETE FROM allowed_users WHERE user_id = ?", (del_user_id,))
            await reload_allowed_users()
            logger.info(f"Пользователь с ID {del_user_id} удалён из списка разрешённых.")
            await message.reply(f"✅ Пользователь с ID {del_user_id} удалён из списка разрешённых.")
        except Exception as e:
            logger.error(f"Ошибка при удалении пользователя из БД: {e}")
            await message.reply(f"❌ Ошибка при удалении пользователя.")
    
    
    @dp.message_handler(commands=['listusers'], state='*')
    async def cmd_list_users(message: types.Message):
        user_id = message.from_user.id
        logger.info(f"Команда /listusers получена от пользователя {user_id}.")
        if not is_admin(user_id):
            logger.warning(f"Пользователь {user_id} не админ, доступ запрещён.")
            await message.reply("❌ У вас нет прав для выполнения этой команды.")
            return
    
        if not ALLOWED_USERS:
            logger.info("Список разрешённых пользователей пуст.")
            await message.reply("Список разрешённых пользователей пуст.")
            return
    
        text = "<b>Список разрешённых пользователей:</b>\n"
        for uid, nick in ALLOWED_USERS.items():
            text += f"• {nick} (ID: {uid})\n"
        logger.debug(f"Отправляем список разрешённых пользователей ({len(ALLOWED_USERS)})")
        await message.reply(text, parse_mode="HTML")
    
    
    if __name__ == '__main__':
        logger.info("Запуск бота...")
        loop = asyncio.get_event_loop()
        loop.run_until_complete(init_db())
        logger.info("База данных инициализирована, стартуем polling.")
        executor.start_polling(dp, skip_updates=True)
    

    Ключевые пункты добавления логов:

    • Логируем начало и успешное выполнение всех крупных частей (инициализация, DB connect, FSM переходы).
    • Логируем ошибки и исключения с подробностями (текст ошибки, параметры).
    • Логируем ключевые действия пользователя (выбор опций, команды, публикация лобби).
    • Логируем проверки доступа и их результаты.
    • Для retries с DB логируем попытки и задержки.
    • Логируем операции добавления/удаления пользователей и результаты.

    Если хотите — могу сделать полный полный изменённый файл с логированием везде. Но из-за объёма тут показаны основные добавления для всех важных мест.

    Теперь у вас будет детальное логирование всего процесса, что упростит отладку и мониторинг работы бота.