import telebot
from telebot import types
import time
import sqlite3
import re

bot = telebot.TeleBot('секрет')  

check_same_thread=False)
cursor = conn.cursor()

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

# Список ID создателей 
CREATOR_IDS = [@Deagle228 сам вводи свой id]  

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

def is_admin(chat_id, user_id):
    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, can_mention=None):
    if can_mute is not None:
        cursor.execute("UPDATE admins SET can_mute = ? WHERE chat_id = ? AND user_id = ?", (can_mute, chat_id, user_id))
    if can_ban is not None:
        cursor.execute("UPDATE admins SET can_ban = ? WHERE chat_id = ? AND user_id = ?", (can_ban, chat_id, user_id))
    if can_mention is not None:
        cursor.execute("UPDATE admins SET can_mention = ? WHERE chat_id = ? AND user_id = ?", (can_mention, 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]
                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)
                    entities = message.entities
                    if entities:
                        user = message.entities[0].user
                    else:
                        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:
        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) or is_creator(user_id)):
        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,
            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}")

# /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) or is_creator(user_id)):
        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,
            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) or is_creator(user_id)):
        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, revoke_messages=True)
        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}")

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

    # Команда доступна только для групповых чатов
    if chat_id > 0:
        return

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

    markup = types.InlineKeyboardMarkup()
    markup.add(types.InlineKeyboardButton("Администрация", callback_data="admin_settings"))
    bot.send_message(user_id, "Настройки чата:", reply_markup=markup)

# Обработчик callback для интерактивных кнопок
@bot.callback_query_handler(func=lambda call: True)
def handle_callback(call):
    chat_id = call.message.chat.id
    user_id = call.from_user.id

    # Проверка доступа для взаимодействия с настройками
    if not (is_admin(chat_id, user_id) or is_creator(user_id)):
        bot.answer_callback_query(call.id, "У вас нет доступа к этим настройкам.")
        return

    if call.data == "admin_settings":
        markup = types.InlineKeyboardMarkup()
        markup.add(
            types.InlineKeyboardButton("Добавить админа", callback_data="add_admin"),
            types.InlineKeyboardButton("Убрать админа", callback_data="remove_admin")
        )
        markup.add(
            types.InlineKeyboardButton("Список админов", callback_data="list_admins"),
            types.InlineKeyboardButton("Разрешения", callback_data="permissions")
        )
        bot.edit_message_text("Администрация:", chat_id=chat_id, message_id=call.message.message_id, reply_markup=markup)
    
    elif call.data == "add_admin":
        msg = bot.send_message(chat_id, "Введите ID пользователя (@123456789):")
        bot.register_next_step_handler(msg, process_add_admin)
    
    elif call.data == "remove_admin":
        msg = bot.send_message(chat_id, "Введите ID пользователя (@123456789) для удаления из админов:")
        bot.register_next_step_handler(msg, process_remove_admin)
    
    elif call.data == "list_admins":
        admins = get_admins(chat_id)
        if admins:
            admin_list = "\n".join([f"• {admin_id}" for admin_id in admins])
            bot.send_message(chat_id, f"Список админов:\n{admin_list}")
        else:
            bot.send_message(chat_id, "Нет админов в этом чате.")
    
    elif call.data == "permissions":
        admins = get_admins(chat_id)
        if not admins:
            bot.send_message(chat_id, "Нет админов для настройки разрешений.")
            return
        markup = types.InlineKeyboardMarkup()
        for admin_id in admins:
            markup.add(types.InlineKeyboardButton(f"Настроить админа {admin_id}", callback_data=f"set_permissions_{admin_id}"))
        markup.add(types.InlineKeyboardButton("Назад", callback_data="admin_settings"))
        bot.send_message(chat_id, "Выберите админа для настройки разрешений:", reply_markup=markup)
    
    elif call.data.startswith("set_permissions_"):
        admin_id = int(call.data.split("_")[-1])
        # Запросить новые разрешения у пользователя
        markup = types.InlineKeyboardMarkup()
        markup.row(
            types.InlineKeyboardButton("Разрешить мутить", callback_data=f"perm_mute_{admin_id}_1"),
            types.InlineKeyboardButton("Запретить мутить", callback_data=f"perm_mute_{admin_id}_0")
        )
        markup.row(
            types.InlineKeyboardButton("Разрешить банить", callback_data=f"perm_ban_{admin_id}_1"),
            types.InlineKeyboardButton("Запретить банить", callback_data=f"perm_ban_{admin_id}_0")
        )
        markup.row(
            types.InlineKeyboardButton("Назад", callback_data="permissions")
        )
        bot.send_message(chat_id, f"Настройка разрешений для админа {admin_id}:", reply_markup=markup)
    
    elif call.data.startswith("perm_"):
        parts = call.data.split("_")
        permission = parts[1]  # 'mute' или 'ban'
        admin_id = int(parts[2])
        value = bool(int(parts[3]))
        
        if permission == "mute":
            cursor.execute("UPDATE admins SET can_mute = ? WHERE chat_id = ? AND user_id = ?", (value, chat_id, admin_id))
        elif permission == "ban":
            cursor.execute("UPDATE admins SET can_ban = ? WHERE chat_id = ? AND user_id = ?", (value, chat_id, admin_id))
        conn.commit()
        bot.send_message(chat_id, f"Разрешение '{permission}' для админа {admin_id} обновлено.")
    
    else:
        bot.answer_callback_query(call.id, "Неизвестная команда.")

# Функции для добавления и удаления админов
def process_add_admin(message):
    chat_id = message.chat.id
    admin_input = message.text.strip()
    match = re.match(r'^@?(\d+)$', admin_input)
    if match:
        admin_id = int(match.group(1))
        add_admin(chat_id, admin_id)
        bot.send_message(chat_id, f"✅ Пользователь {admin_id} добавлен в администраторы.")
    else:
        bot.send_message(chat_id, "❌ Неправильный формат ID. Пожалуйста, используйте числовой ID.")
    
def process_remove_admin(message):
    chat_id = message.chat.id
    admin_input = message.text.strip()
    match = re.match(r'^@?(\d+)$', admin_input)
    if match:
        admin_id = int(match.group(1))
        remove_admin(chat_id, admin_id)
        bot.send_message(chat_id, f"✅ Пользователь {admin_id} удален из администраторов.")
    else:
        bot.send_message(chat_id, "❌ Неправильный формат ID. Пожалуйста, используйте числовой ID.")

# Обработчик всех остальных сообщений
@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) or is_creator(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:
            print(message.text)

# Запуск бота
bot.infinity_polling() при запуске сразу закрывается, чекни ошибки и дай исправленный код