```python
import telebot
from telebot import types
import time
import sqlite3
import re
import logging

# Настройка логирования
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

bot = telebot.TeleBot('токен')


conn = sqlite3.connect('Eblan.db', check_same_thread=False)
cursor = conn.cursor()


cursor.execute("""
CREATE TABLE IF NOT EXISTS admins (
    chat_id INTEGER,
    user_id INTEGER,
    can_mute BOOLEAN DEFAULT 1,
    can_ban BOOLEAN DEFAULT 1,
    PRIMARY KEY (chat_id, user_id)
)
""")
conn.commit()

# Бан ворды
bad_words = ['как скачать', 'дай тутор', 'дай чит']

# Список ID создателей 
CREATOR_IDS = [5177470092] 

# Функции для работы с администраторами
def get_admins(chat_id):
    cursor.execute("SELECT user_id, can_mute, can_ban FROM admins WHERE chat_id = ?", (chat_id,))
    return cursor.fetchall()

def is_admin(chat_id, user_id):
    if is_creator(user_id):
        return True  # Создатель автоматически считается администратором
    cursor.execute("SELECT * FROM admins WHERE chat_id = ? AND user_id = ?", (chat_id, user_id))
    return cursor.fetchone() is not None

def is_creator(user_id):
    return user_id in CREATOR_IDS

def add_admin(chat_id, user_id):
    cursor.execute("INSERT OR IGNORE INTO admins (chat_id, user_id) VALUES (?, ?)", (chat_id, user_id))
    conn.commit()

def remove_admin(chat_id, user_id):
    cursor.execute("DELETE FROM admins WHERE chat_id = ? AND user_id = ?", (chat_id, user_id))
    conn.commit()

def update_permissions(chat_id, user_id, can_mute=None, can_ban=None):
    if is_creator(user_id):
        # Создатель всегда имеет все права, никаких изменений не требуется
        return
    if can_mute is not None and can_ban is not None:
        cursor.execute("UPDATE admins SET can_mute = ?, can_ban = ? WHERE chat_id = ? AND user_id = ?", 
                       (can_mute, can_ban, chat_id, user_id))
    elif can_mute is not None:
        cursor.execute("UPDATE admins SET can_mute = ? WHERE chat_id = ? AND user_id = ?", 
                       (can_mute, chat_id, user_id))
    elif can_ban is not None:
        cursor.execute("UPDATE admins SET can_ban = ? WHERE chat_id = ? AND user_id = ?", 
                       (can_ban, chat_id, user_id))
    conn.commit()

def parse_duration(duration_str):
    pattern = r'^(\d+)([mhd])$'
    match = re.match(pattern, duration_str.lower())
    if not match:
        return None
    value, unit = match.groups()
    value = int(value)
    if unit == 'm':
        return value * 60
    elif unit == 'h':
        return value * 3600
    elif unit == 'd':
        if value > 30:
            return 30 * 86400  # Макс. 30 дней
        return value * 86400
    return None

def check_message(message):
    if message.text:
        message_text = message.text.lower()
        for word in bad_words:
            if word in message_text:
                return True
    return False

# /inf команда для получения информации о пользователе
@bot.message_handler(commands=['inf'])
def inf_command(message):
    try:
        if message.reply_to_message:
            user = message.reply_to_message.from_user
        else:
            args = message.text.split()
            if len(args) > 1:
                user = None
                mention = args[1]
                # Попытка распознать ID пользователя
                match = re.match(r'^@?(\d+)$', mention)
                if match:
                    user_id = int(match.group(1))
                    user = bot.get_chat_member(message.chat.id, user_id).user
                else:
                    # Попытка получить информацию по упоминанию (@username)
                    try:
                        user = bot.get_chat(message.chat.id).get_member_by_username(mention).user
                    except AttributeError:
                        user = None
            else:
                user = message.from_user

        if user:
            user_info = f"""
<b>User Information:</b>
• <b>Username:</b> @{user.username if user.username else 'Отсутствует'} 
• <b>Name:</b> {user.first_name} {user.last_name or ''}
• <b>ID:</b> {user.id}
"""
            bot.send_message(message.chat.id, user_info, parse_mode='HTML')
        else:
            bot.reply_to(message, "Не удалось найти пользователя.")
    except Exception as e:
        logger.error(f"Error in /inf command: {e}")
        bot.reply_to(message, f"Ошибка: {e}")

# /eblan команда для мутирования пользователя
@bot.message_handler(commands=['eblan'])
def mute_user(message):
    chat_id = message.chat.id
    user_id = message.from_user.id

    if not is_admin(chat_id, user_id):
        bot.send_message(chat_id, 'У вас нет доступа к этой команде.')
        return

    # Проверка прав на мутирование
    if not (is_creator(user_id) or has_permission(chat_id, user_id, 'can_mute')):
        bot.send_message(chat_id, 'У вас нет прав на мутирование пользователей.')
        return

    if not message.reply_to_message:
        bot.reply_to(message, "Пожалуйста, используйте команду в ответе на сообщение пользователя, которого хотите мутить.")
        return

    target_user = message.reply_to_message.from_user
    target_user_id = target_user.id

    if is_admin(chat_id, target_user_id) or is_creator(target_user_id) or target_user_id == bot.get_me().id:
        bot.reply_to(message, "Ты не можешь мутить администраторов, создателей или самого бота.")
        return

    args = message.text.split()[1:]
    duration = 60  # По умолчанию 1 минута
    reason = None

    if args:
        duration_input = args[0]
        duration_sec = parse_duration(duration_input)
        if duration_sec is None:
            bot.reply_to(message, "Неправильный формат времени.\nПример: /eblan 3d Причина")
            return
        duration = duration_sec
        if len(args) > 1:
            reason = ' '.join(args[1:])

    try:
        bot.restrict_chat_member(
            chat_id,
            target_user_id,
            permissions=types.ChatPermissions(
                can_send_messages=False,
                can_send_media_messages=False,
                can_send_other_messages=False,
                can_add_web_page_previews=False
            ),
            until_date=int(time.time()) + duration
        )
        readable_duration = ""
        if duration >= 86400:
            days = duration // 86400
            readable_duration = f"{days} день(дней)"
        elif duration >= 3600:
            hours = duration // 3600
            readable_duration = f"{hours} час(ов)"
        else:
            minutes = duration // 60
            readable_duration = f"{minutes} минут(ы)"

        if reason:
            bot.reply_to(message, f"🛑 {target_user.first_name} мутирован на {readable_duration}. Причина: {reason}")
        else:
            bot.reply_to(message, f"🛑 {target_user.first_name} мутирован на {readable_duration}.")
    except telebot.apihelper.ApiException as e:
        bot.send_message(chat_id, f"Не удалось мутировать пользователя: {e}")

def has_permission(chat_id, user_id, permission):
    cursor.execute(f"SELECT {permission} FROM admins WHERE chat_id = ? AND user_id = ?", (chat_id, user_id))
    result = cursor.fetchone()
    return result[0] if result else False

# /uneblan команда для размьюта пользователя
@bot.message_handler(commands=['uneblan'])
def unmute_user(message):
    chat_id = message.chat.id
    user_id = message.from_user.id

    if not is_admin(chat_id, user_id):
        bot.send_message(chat_id, 'У вас нет доступа к этой команде.')
        return

    # Проверка прав на размьют
    if not (is_creator(user_id) or has_permission(chat_id, user_id, 'can_mute')):
        bot.send_message(chat_id, 'У вас нет прав на размьют пользователей.')
        return

    if not message.reply_to_message:
        bot.reply_to(message, "Пожалуйста, используйте команду в ответе на сообщение пользователя, которого хотите размьютить.")
        return

    target_user = message.reply_to_message.from_user
    target_user_id = target_user.id

    try:
        bot.restrict_chat_member(
            chat_id,
            target_user_id,
            permissions=types.ChatPermissions(
                can_send_messages=True,
                can_send_media_messages=True,
                can_send_other_messages=True,
                can_add_web_page_previews=True
            )
        )
        bot.reply_to(message, f"✅ {target_user.first_name} размьютен.")
    except telebot.apihelper.ApiException as e:
        bot.send_message(chat_id, f"Не удалось размьютить пользователя: {e}")

# /ebalan228 команда для бана пользователя
@bot.message_handler(commands=['ebalan228'])
def ban_user(message):
    chat_id = message.chat.id
    user_id = message.from_user.id

    if not is_admin(chat_id, user_id):
        bot.send_message(chat_id, 'У вас нет доступа к этой команде.')
        return

    # Проверка прав на бан
    if not (is_creator(user_id) or has_permission(chat_id, user_id, 'can_ban')):
        bot.send_message(chat_id, 'У вас нет прав на бан пользователей.')
        return

    if not message.reply_to_message:
        bot.reply_to(message, "Пожалуйста, используйте команду в ответе на сообщение пользователя, которого хотите забанить.")
        return

    target_user = message.reply_to_message.from_user
    target_user_id = target_user.id

    if is_admin(chat_id, target_user_id) or is_creator(target_user_id) or target_user_id == bot.get_me().id:
        bot.reply_to(message, "Нельзя банить администраторов, создателей или самого бота.")
        return

    args = message.text.split()[1:]
    reason = None

    if args:
        reason = ' '.join(args)

    try:
        bot.kick_chat_member(chat_id, target_user_id, until_date=0)
        if reason:
            bot.send_message(chat_id, f"🔨 {target_user.first_name} забанен. Причина: {reason}")
        else:
            bot.send_message(chat_id, f"🔨 {target_user.first_name} забанен.")
    except telebot.apihelper.ApiException as e:
        bot.send_message(chat_id, f"Не удалось забанить пользователя: {e}")

# /add_adm @id — добавить администратора (только создатель)
@bot.message_handler(commands=['add_adm'])
def add_adm_command(message):
    chat_id = message.chat.id
    user_id = message.from_user.id

    if not is_creator(user_id):
        bot.send_message(chat_id, 'У вас нет доступа к этой команде.')
        return

    args = message.text.split()
    if len(args) != 2:
        bot.reply_to(message, "Неверный формат. Используйте: /add_adm @id или /add_adm ID")
        return

    mention = args[1]
    match = re.match(r'^@?(\d+)$', mention)
    if match:
        admin_id = int(match.group(1))
        # Проверяем, существует ли пользователь в чате
        try:
            user = bot.get_chat_member(chat_id, admin_id).user
            add_admin(chat_id, admin_id)
            bot.send_message(chat_id, f"✅ Пользователь {user.first_name} ({admin_id}) добавлен в администрацию.")
        except telebot.apihelper.ApiException:
            bot.send_message(chat_id, "❌ Не удалось найти пользователя с таким ID в этом чате.")
    else:
        bot.send_message(chat_id, "❌ Неправильный формат ID. Пожалуйста, используйте числовой ID или @username.")

# /rem_adm @id — удалить администратора (только создатель)
@bot.message_handler(commands=['rem_adm'])
def rem_adm_command(message):
    chat_id = message.chat.id
    user_id = message.from_user.id

    if not is_creator(user_id):
        bot.send_message(chat_id, 'У вас нет доступа к этой команде.')
        return

    args = message.text.split()
    if len(args) != 2:
        bot.reply_to(message, "Неверный формат. Используйте: /rem_adm @id или /rem_adm ID")
        return

    mention = args[1]
    match = re.match(r'^@?(\d+)$', mention)
    if match:
        admin_id = int(match.group(1))
        remove_admin(chat_id, admin_id)
        bot.send_message(chat_id, f"✅ Пользователь с ID {admin_id} удалён из администраторов.")
    else:
        bot.send_message(chat_id, "❌ Неправильный формат ID. Пожалуйста, используйте числовой ID или @username.")

# /admins — показать список администраторов
@bot.message_handler(commands=['admins'])
def list_admins_command(message):
    chat_id = message.chat.id
    user_id = message.from_user.id

    if not is_admin(chat_id, user_id):
        bot.send_message(chat_id, 'У вас нет доступа к этой команде.')
        return

    admins = get_admins(chat_id)
    creator_section = ""
    if is_creator(user_id):
        creator_section = "\n<b>Создатели:</b>\n" + "\n".join([f"• {cid}" for cid in CREATOR_IDS])

    if not admins and not creator_section:
        bot.send_message(chat_id, "Нет администраторов в этом чате.")
        return

    admin_list = "<b>Администраторы:</b>\n"
    admin_list += "<pre>ID | Имя | Мут | Бан</pre>\n"
    admin_list += "-------------------------------------\n"
    for admin in admins:
        admin_id, can_mute, can_ban = admin
        try:
            user = bot.get_chat_member(chat_id, admin_id).user
            name = f"{user.first_name} {user.last_name or ''}".strip()
        except telebot.apihelper.ApiException:
            name = "Неизвестный пользователь"
        mute_status = "Да" if can_mute else "Нет"
        ban_status = "Да" if can_ban else "Нет"
        admin_list += f"{admin_id} | {name} | {mute_status} | {ban_status}\n"

    if creator_section:
        admin_list += creator_section

    bot.send_message(chat_id, admin_list, parse_mode='HTML')

# /rule_adm_m @id y/n — установить разрешение на мут (только создатель)
@bot.message_handler(commands=['rule_adm_m'])
def rule_adm_m_command(message):
    chat_id = message.chat.id
    user_id = message.from_user.id

    if not is_creator(user_id):
        bot.send_message(chat_id, 'У вас нет доступа к этой команде.')
        return

    args = message.text.split()
    if len(args) != 3:
        bot.reply_to(message, "Неверный формат. Используйте: /rule_adm_m @id y/n")
        return

    mention = args[1]
    permission = args[2].lower()

    match = re.match(r'^@?(\d+)$', mention)
    if not match:
        bot.send_message(chat_id, "❌ Неправильный формат ID. Пожалуйста, используйте числовой ID или @username.")
        return

    admin_id = int(match.group(1))

    if permission not in ['y', 'n']:
        bot.send_message(chat_id, "❌ Неверное значение разрешения. Используйте 'y' для Да или 'n' для Нет.")
        return

    can_mute = True if permission == 'y' else False
    update_permissions(chat_id, admin_id, can_mute=can_mute)

    status = "разрешено" if can_mute else "запрещено"
    bot.send_message(chat_id, f"✅ Разрешение на мут для администратора {admin_id} {status}.")

# /rule_adm_b @id y/n — установить разрешение на бан (только создатель)
@bot.message_handler(commands=['rule_adm_b'])
def rule_adm_b_command(message):
    chat_id = message.chat.id
    user_id = message.from_user.id

    if not is_creator(user_id):
        bot.send_message(chat_id, 'У вас нет доступа к этой команде.')
        return

    args = message.text.split()
    if len(args) != 3:
        bot.reply_to(message, "Неверный формат. Используйте: /rule_adm_b @id y/n")
        return

    mention = args[1]
    permission = args[2].lower()

    match = re.match(r'^@?(\d+)$', mention)
    if not match:
        bot.send_message(chat_id, "❌ Неправильный формат ID. Пожалуйста, используйте числовой ID или @username.")
        return

    admin_id = int(match.group(1))

    if permission not in ['y', 'n']:
        bot.send_message(chat_id, "❌ Неверное значение разрешения. Используйте 'y' для Да или 'n' для Нет.")
        return

    can_ban = True if permission == 'y' else False
    update_permissions(chat_id, admin_id, can_ban=can_ban)

    status = "разрешено" if can_ban else "запрещено"
    bot.send_message(chat_id, f"✅ Разрешение на бан для администратора {admin_id} {status}.")

# /help или /h — показать все команды с объяснениями
@bot.message_handler(commands=['help', 'h'])
def help_command(message):
    help_text = """
<b>Доступные команды:</b>

• <b>/inf</b> — Получить информацию о пользователе. Используйте в ответе на сообщение или укажите @username или ID.
• <b>/eblan</b> — Замьютить пользователя. Используйте в ответе на сообщение пользователя. Можно указать длительность и причину. Пример: /eblan 10m Причина
• <b>/uneblan</b> — Размьютить пользователя. Используйте в ответе на сообщение пользователя.
• <b>/ebalan228</b> — Забанить пользователя. Используйте в ответе на сообщение пользователя. Можно указать причину.
• <b>/admins</b> — Показать список администраторов с их разрешениями.
• <b>/add_adm @id</b> — Добавить администратора. (Только создатель)
• <b>/rem_adm @id</b> — Удалить администратора. (Только создатель)
• <b>/rule_adm_m @id y/n</b> — Разрешить или запретить администратору мутить. (Только создатель)
• <b>/rule_adm_b @id y/n</b> — Разрешить или запретить администратору банить. (Только создатель)
• <b>/help</b> или <b>/h</b> — Показать это сообщение.
"""

    bot.send_message(message.chat.id, help_text, parse_mode='HTML')

# Обработчик всех остальных сообщений
@bot.message_handler(func=lambda message: True)
def handle_message(message):
    if message.text and check_message(message):
        chat_id = message.chat.id
        user_id = message.from_user.id

        # Не банить админов и создателей
        if is_admin(chat_id, user_id):
            return

        try:
            bot.ban_chat_member(chat_id, user_id)
            bot.send_message(chat_id, f"🚫 Eblan Detected - {message.from_user.first_name} забанен.")
        except telebot.apihelper.ApiException as e:
            bot.send_message(chat_id, f"❗ Не удалось забанить пользователя: {e}")
    else:
        if message.text:
            logger.info(f"Сообщение: {message.text}")

if __name__ == "__main__":
    try:
        bot.infinity_polling()
    except KeyboardInterrupt:
        logger.info("Бот остановлен вручную.")
    except Exception as e:
        logger.error(f"Ошибка при запуске бота: {e}")```
улучшь дизайн бота, сделай нормальные слова (по типу мут, размут, разбан, бан, кик, настройки в чате, например: анти флуд, капча и м.д для чата